Smart Night Light & Alarm Clock

#include "credentials.h"  //Blynk & WiFi credentials
//#define BLYNK_PRINT Serial  //only for debug, comment out in production
#include <WiFiNINA.h>
#include <BlynkSimpleWifi.h>
#include <Arduino_MKRIoTCarrier.h>
MKRIoTCarrier nightBox;
#include <SPI.h>;
#include <SD.h>
#include "globalVars.h"

void setup() {
  Serial.begin(115200); delay(1000);
  Serial.println("setup begin");
  CARRIER_CASE = true;  //------change to TRUE once in production
  nightBox.begin();
  nightBox.display.fillScreen(noColor);
  nightBox.display.drawBitmap(60,5,wifi_image,50,30,Gray);
  pinMode(BUZZER, OUTPUT);
  pinMode(GROVE_AN2, INPUT);
  pinMode(A0, OUTPUT);
  digitalWrite(14, LOW);
  rtc.begin();
  Blynk.begin(auth, ssid, pass);  
  WiFi_ON = true;
  while (!Blynk.connected()) { // to avoid time out and not connect
    Serial.print("."); delay(10);}
  Blynk.syncAll();
  unsigned long startSync = millis();
  Serial.print("Wait 3 sec for sync of Blynk Vars.");  //ocurring async from syncAll cmd
  while (millis() - startSync < 3000) {
    Serial.print("."); delay(100);} 
  Serial.println("\nsetup end");
}
//--------------END OF SETUP---------------------------

void loop() {
  Blynk.run();
  chkShake();
  updateBatt();
  updateClock();
  chkAlarm(); 
  if (!wakeSeqStarted) {
    stateVar = 0;
    chkMove(); 
    chkLums();
    chkTimeSlot();
    chkCalm();
    if (itIsCalm) stateVar += 8; 
    if (stateVar!= lastStateVar) {
      //Serial.print("stateVar="+String(stateVar)+" BIN:");Serial.println(stateVar,BIN);
      lastStateVar = stateVar;
      if (stateVar == 2 || stateVar == 3 || stateVar == 10) 
        dispClock(Blue); else dispClock(Red);
      if (stateVar == 0 || stateVar == 1 || stateVar == 4 || stateVar == 5 ||
          stateVar == 8 || stateVar == 12)
        setLeds("Night",nightBrightness); else setLeds("Off",0);
      if (stateVar == 5) whiteNoise(1);
      if (stateVar == 7) whiteNoise(2);
      if (stateVar == 6 || stateVar == 7) setWiZ("stateVar_67");
      if (stateVar == 14) setWiZ("WiZ_Off");
    }
  }else {
    if (millis() - wakeMillis < 600000) { //wake sequence takes 10 minutes (60sec * 1000millis * 10 minutes)
      if (millis() - lastWakeStep > 9500) { //increase LED brightness every 9.5 seconds to ensure total brightness < 255
        lastWakeStep = millis();
        wakeInc += 4; 
        setLeds("Alarm",wakeInc);
        if (wakeInc == 100) singUnderworld();
        if (wakeInc == 180) singMario();
      } 
    }else {
      wakeSeqStarted = false;  //wake sequence ended because 10 mins have passed
      setLeds("Off",0); 
    }
  }
}
//--------------END OF LOOP------------------------------

//--------------FUNCTIONS TO TRIGGER RESPONSES-----------
void chkShake() {
  float Gx, Gy, Gz;
  nightBox.IMUmodule.readGyroscope(Gx, Gy, Gz);
  if ((Gy < -100 || Gx < -100 || Gz < -100) && WiFi_ON) {
      Blynk.disconnect();
      WiFi.disconnect();
      WiFi.end();
      nightBox.display.fillRect(60,5,50,30,noColor);
      WiFi_ON = false;
  }
}
void setWiZ(String action) {
  //Serial.println("setWiZ: "+action);
  if (!WiFi_ON) {
    int status = WL_IDLE_STATUS;
    while (status != WL_CONNECTED) {
      //Serial.println("reconnecting WiFi for WiZ");
      status = WiFi.begin(ssid, pass);
      delay(3000);
    }
    nightBox.display.drawBitmap(60,5,wifi_image,50,30,Red);
  }
  if (client.connect(server, 443)) {
    Serial.println("connected to server");
    String httpGET = "GET https://maker.ifttt.com/trigger/" + action + "/with/key/" + IFTTT_Key;
    client.println(httpGET);
    client.println("Connection: close");
    client.println();
    Serial.println("Connection closed");
    if (!client.connected()) {        // if the server is disconnected, stop the client:
     Serial.println("disconnecting from server");
     client.stop();
    }
    delay(1000); //time for IFTTT to settle in case another one is called immediately after
  }
  if (!WiFi_ON) {
    WiFi.disconnect();
    WiFi.end();
    nightBox.display.fillRect(60,5,50,30,noColor);
  }
}
void whiteNoise(uint8_t fileNum) {
  //for white or brown noise see https://www.audiocheck.net/testtones_brownnoise.php
  digitalWrite(14, HIGH); //turn on the amplifier
  AudioPlayer.begin(44100, 1, 512);  //sample rate, number of simultaneous audio channels, audio buffer size
  if (fileNum == 1) AudioPlayer.play("bNoise10.wav"); //filenames must have 8 chars max
  if (fileNum == 2) AudioPlayer.play("bNoise20.wav");
  while (AudioPlayer.isPlaying(1)) { } //block execution to avoid conflicts with CLKs and other stuff
  AudioPlayer.end();
  digitalWrite(14, LOW); 
}
void setLeds(String newState, byte newBright) {
  static String ledsState = "";
  static byte brightState = 0;
  if (ledsState != newState || brightState != newBright) {
    ledsState = newState; 
    brightState = newBright;
    if (newState == "Night") nightBox.leds.fill(Orange,0,5); 
    if (newState == "Alarm") nightBox.leds.fill(BlueLED,0,5);
    if (newState == "Off") nightBox.leds.fill(noColor,0,5);
    nightBox.leds.setBrightness(newBright);
    nightBox.leds.show();
  }
}
void dispClock(uint16_t setColor) {
  static uint16_t clockState = 0;
  byte t = clockTextSize; //clock number text size 
  byte w = localTime.length()*(5+1)*t; //clock number width
  byte h = 7 * t; //clock number height
  if (clockState != setColor) {
    if (setColor != keepColor) clockState = setColor;
    nightBox.display.fillRect(0,(240-h)/2-1,240,h+2,noColor); 
    nightBox.display.setTextColor(clockState);
    nightBox.display.setTextSize(t);
    nightBox.display.setCursor((240-w)/2+1,(240-h)/2);
    nightBox.display.print(localTime);
  }
}
//--------------FUNCTIONS TO CHECK STATES----------------
void chkAlarm() {
  if (alarmStatus == 1) {
    if (wakeHour == hour && wakeMinute == minute && !wakeSeqStarted) {
      wakeMillis = millis();
      wakeSeqStarted = true;
      lastWakeStep = 0;  
      wakeInc = 0;    
      setWiZ("wakeSeqStarted");  
    }
  }else {
    if (wakeSeqStarted) { //alamrmStatus changed to OFF during a wakeSequenceStarted
      wakeSeqStarted = false; //wake sequence ended because change in alarmStatus
      setLeds("Off",0);  
    }
  }
}
void chkCalm() {
  if (millis() - firstMove > calmPeriod && !moved) {
    itIsCalm = true; //stateVar += 8; will set fourth bit of state variable byte in main loop
    firstMove = millis();
  }
}
void chkTimeSlot() { //designed (i.e. works) only for timeSlotBegin < 24 and timeSlotEnd > 0
  if (hour >= timeSlotBegin || hour < timeSlotEnd) { //hour is in 24hr format, localtime is 12hr format
      stateVar += 4; //set third bit of state variable byte
    }
}
void chkLums() {
  while (!nightBox.Light.colorAvailable()) delay(5);
  int r,g,b,lums,acumLums;
  int lumsLevel;
  float depaso;
  acumLums = 0;
  for (int i=0; i<20; i++) {
    nightBox.Light.readColor(r,g,b,lums); 
    depaso = r * 100 / b;
    //Serial.print(depaso);Serial.print(",");Serial.println(lums);
    acumLums += lums; }
  lums = acumLums / 20;  // average 20 samples to assist hysteresis
  lumsLevel = getHystLevel(lums);  //see Hysteresis function at bottom
  if (lumsLevel > lumsLimit && depaso < redToBlue) {
    stateVar += 2;  //set second bit of state variable byte
  }
}
void chkMove() {
  static int moveCounter;
  static unsigned long nextPIRread;
  int PIR_val = digitalRead(GROVE_AN2); 
  if (PIR_val == HIGH && !moved) {  //it's the first movement detected since startup or flag reset
      moved = true;
      firstMove = millis();
      moveCounter = 0;
      //Serial.println("first move");
  }
  if (moved) {
    if (millis() - firstMove > mutePeriod) {  //mute period is over
      if (millis() - firstMove < movePeriod + mutePeriod) {  //still inside Move Eval Period 
        if (millis() - nextPIRread > 1000) {  //limit subsecuent PIR sensor reads to once per second
          PIR_val = digitalRead(GROVE_AN2);  
          nextPIRread = millis();
          if (PIR_val == HIGH) {moveCounter += 1;}//Serial.println("next move");} 
        }   
      }else { //Move Eval Period has expired
        moved = false;
        if (moveCounter > moveCounterLimit) 
          {stateVar += 1;  //set first bit of state variable byte
          itIsCalm = false;}
      }
    } //if mute period is not over, then do nothing
  } //if no movement detetcted, then do nothing
}
//--------------FUNCTIONS TO DISPLAY DATA----------------
void updateBatt() {
  static unsigned long lastBattRead = 0;
  static byte lastBattPercent = 0;
  if (millis() - lastBattRead > 5000) {  //read Batt every 10 seconds to mitigate Hysteresis
    lastBattRead = millis();  
    int battSensor = analogRead(ADC_BATTERY);
    int battPercent = map(battSensor,0,1023,0,100); 
    if (battPercent != lastBattPercent){   
      lastBattPercent = battPercent;                     
      int length = map(battPercent,73,100,1,25); //map battPercent to 25 pixels @ 73% = 3.1v (brownout cutoff)
      nightBox.display.fillRect(108,5,36,39,noColor);  //clear the battery display
      uint16_t setColor = Gray;
      if (battPercent < 78) setColor = Red; //75% = 3.15v
      nightBox.display.drawRect(108,5,27,13,setColor);
      nightBox.display.fillRect(135,9,3,5,setColor);
      nightBox.display.fillRect(110,7,length,9,setColor);    
      nightBox.display.setCursor(112,25);     
      nightBox.display.setTextSize(1);
      nightBox.display.setTextColor(Gray); 
      nightBox.display.print(String(battPercent) + "%");       
    }
  }
}
void updateClock() {
  if (rtc.getMinutes() != minute) {   
    hour = rtc.getHours();
    minute = rtc.getMinutes();
    if (hour>12) localTime = String(hour - 12);
    else localTime = String(hour);
    localTime.trim();
    if (minute<10) localTime = localTime + ":0" + String(minute);
    else localTime = localTime + ":" + String(minute);
    dispClock(keepColor);  
  }
}
void dispAlarm() {
  String alarmTime = String(alarmHour) + ":"; 
  if (alarmMinute > 9) alarmTime = alarmTime + String(alarmMinute);
  else alarmTime = alarmTime + "0" + String(alarmMinute);
  nightBox.display.fillRect(0, 200, 239, 239, noColor);
  nightBox.display.setTextColor(Gray);
  nightBox.display.setTextSize(2);
  nightBox.display.setCursor(100,210);
  nightBox.display.print(alarmTime);
  if (alarmStatus == 1) nightBox.display.fillCircle(83,217,5,Gray);
  else nightBox.display.fillCircle(83,217,5,noColor);
}
//--------------BLYNK FUNCTIONS--------------------------
BLYNK_WRITE(V0) {
  alarmHour = param.asInt();
  dispAlarm();
}
BLYNK_WRITE(V1) {
  alarmMinute = param.asInt();
  dispAlarm();
}
BLYNK_WRITE(V2) {
  alarmStatus = param.asInt();
  dispAlarm();
  wakeMinute = alarmMinute - 10;
  wakeHour = alarmHour;
  if (wakeMinute < 0) {
    wakeMinute += 60;
    wakeHour -= 1;
  }
}
BLYNK_WRITE(V3) {
  lumsLimit = param.asInt();
}
BLYNK_WRITE(V4) {
  nightBrightness = param.asInt();
}
BLYNK_WRITE(V5) {
  timeSlotBegin = param.asInt();
}
BLYNK_WRITE(V6) {
  timeSlotEnd = param.asInt();
}
BLYNK_WRITE(V7) {
  moveCounterLimit = param.asInt();
}
BLYNK_WRITE(V8) {
  clockTextSize = param.asInt();
}
BLYNK_WRITE(V9) {
  redToBlue = param.asInt();
}
BLYNK_CONNECTED() {
  // Serial.println("\nStarting blynk connected");
  // this is executed before end of setup, asynchronus from Blynk.begin?
  Blynk.sendInternal("utc", "iso"); // ISO-8601 formatted time: requests for different internal data
  // for full time zone data https://docs.blynk.io/en/blynk.edgent/api/timezone-location
}
BLYNK_WRITE(InternalPinUTC) {
  //asynchronus: arrives after setup, even after first loop iteration. chk Blynk.run()
  String iso_time;
  String cmd = param[0].asStr();
  if (cmd == "iso") iso_time = param[1].asStr(); 
  Serial.print("ISO-8601 time:   "); Serial.println(iso_time);  //to chk in case format moves
  int isoIndex = iso_time.indexOf('T');
  String isoHour   = iso_time.substring(isoIndex + 1, isoIndex + 3);
  String isoMinute = iso_time.substring(isoIndex + 4, isoIndex + 6);
  String isoSecond = iso_time.substring(isoIndex + 7, isoIndex + 9);
  rtc.setHours(isoHour.toInt());
  rtc.setMinutes(isoMinute.toInt());
  rtc.setSeconds(isoSecond.toInt());
}
//--------------AUXILIARY FUNCTIONS----------------------
int getHystLevel(int inputLevel) {
  // Note for SmartNightLight: table is nonlinear since only interest is dark/not dark room. 
  // Other or later functions may use varying levels of room lums
    
  // From:  Hysteresis  https://forum.arduino.cc/t/hysteresis/506190
  //  convert an input value into an output value with hysteresis
  // ========================================
  // margin sets the 'stickyness' of the hysteresis or the relucatance to leave the current state.
  // It is measured in units of the the input level. As a guide it is a few percent of the
  // difference between two end points. Don't make the margin too wide or ranges may overlap.
  int margin = 0;  //modified for non-linear margin
  // set the number of output levels. These are numbered starting from 0.
  const byte numberOfLevelsOutput = 7;  
  // define input to output conversion table/formula by specifying endpoints of the levels.
  // the number of end points is equal to the number of output levels plus one.
  const int endPointInput[numberOfLevelsOutput + 1] = {0,10,30,90,270,540,1620,4097} ;
  // initial output level (usually zero)
  const int initialOutputLevel = 0;
  // ========================================
  // the current output level is retained for the next calculation.
  // Note: initial value of a static variable is set at compile time.
  static int currentOutputLevel = initialOutputLevel ;
  
  //-----My Mod for SmartNightLight: non linear margin:
  if (currentOutputLevel < numberOfLevelsOutput)
    margin = (endPointInput[currentOutputLevel+1] - endPointInput[currentOutputLevel]) * 0.1;
  else
    margin = endPointInput[currentOutputLevel] * 0.1;
    
  // get lower and upper bounds for currentOutputLevel
  int lb = endPointInput[currentOutputLevel];
  if (currentOutputLevel > 0) lb -= margin ;   // subtract margin
  int ub = endPointInput[currentOutputLevel + 1];
  if (currentOutputLevel < numberOfLevelsOutput) ub +=  margin ;  // add margin
  // now test if input is between the outer margins for current output value
  byte i;
  if (inputLevel < lb || inputLevel > ub) {
    for (i=0; i<numberOfLevelsOutput; i++)  // determine new output level by scanning endPointInput array
      if (inputLevel >= endPointInput[i] && inputLevel <= endPointInput[i+1]) break;
    currentOutputLevel = i ;
  }
  return currentOutputLevel ;
}