Akyn the device that takes care of everything, so you don’t have to.

#include <Servo.h>

Servo servo_lights_off;
Servo servo_AC;

int pin_GM_button = 2;
int pin_GN_button = 4;

int pin_lights_off = 11;
int pin_AC = 9;

int state_GM_button = 0;
int state_GN_button = 0;
int prev_state_GM_button = 0;
int prev_state_GN_button = 0;

void setup() {
  servo_lights_off.attach(pin_lights_off);
  servo_AC.attach(pin_AC);
  Serial.begin(9600);

  // start the handshake
  while (Serial.available() <= 0) {
    Serial.println("-1"); // send a starting message
    delay(300);            // wait 1/3 second
  }
}

void loop() {
  while (Serial.available()) {
    state_GM_button = digitalRead(pin_GM_button);
    state_GN_button = digitalRead(pin_GN_button);
    // GM button is pressed
    if (state_GM_button != prev_state_GM_button && state_GM_button == 1) {
      // turn on the AC
      servo_AC.write(180);
      delay(1000);
      servo_AC.write(0);
      delay(1000);
      
      // send message to P5.js
      Serial.println("0");
    }
    // GN button is pressed
    if (state_GN_button != prev_state_GN_button && state_GN_button == 1) {
      // turn off the lights
      servo_lights_off.write(0);
      delay(1000);
      servo_lights_off.write(180);
      delay(1000);
      // turn off the AC, double click is needed to go to Night mode from Morning mode
      servo_AC.write(180);
      delay(1000);
      servo_AC.write(0);
      delay(2000);
      servo_AC.write(180);
      delay(1000);
      servo_AC.write(0);
      delay(2000);

      // send message to P5.js
      Serial.println("1");
    }
    
    // update the previous states of the buttons
    prev_state_GM_button = state_GM_button;
    prev_state_GN_button = state_GN_button;
  }
}

• When the user starts the code after a specific amount of time(10 seconds for the user to have some time to read the instructions) authorization script is run. This script sends requests to Google Calendar API and Gmail API over the gapi library. As a result, I am now able to send get requests to the Google API. After the authorization, I load the calendar using a specific query indicating what kind of events I want to see. All of this is saved into the CALENDAR_EVENTS variable

  <script>
  
      const gapiLoadPromise = new Promise((resolve, reject) => {
        gapiLoadOkay = resolve;
        gapiLoadFail = reject;
      });
      const gisLoadPromise = new Promise((resolve, reject) => {
        gisLoadOkay = resolve;
        gisLoadFail = reject;
      });
  
      var tokenClient;
  
      (async () => {
        // First, load and initialize the gapi.client
        await gapiLoadPromise;
        await new Promise((resolve, reject) => {
          // NOTE: the 'auth2' module is no longer loaded.
          gapi.load('client', {callback: resolve, onerror: reject});
        });
        await gapi.client.init({
          // NOTE: OAuth2 'scope' and 'client_id' parameters have moved to initTokenClient().
        })
        .then(function() {  // Load the Google API's discovery document.
          gapi.client.load('https://www.googleapis.com/discovery/v1/apis/calendar/v3/rest');
          gapi.client.load('https://www.googleapis.com/discovery/v1/apis/gmail/v1/rest');
        });
  
        // Now load the GIS client
        await gisLoadPromise;
        await new Promise((resolve, reject) => {
          try {
            tokenClient = google.accounts.oauth2.initTokenClient({
                client_id: google_calendar_USER_ID,
                scope: 'https://www.googleapis.com/auth/calendar.readonly https://www.googleapis.com/auth/gmail.readonly',
                prompt: 'consent',
                callback: '',  // defined at request time in await/promise scope.
            });
            resolve();
          } catch (err) {
            reject(err);
          }
        });
      })();
  
      // get token in case error while authorizing appeared
      async function getToken(err) {
  
        if (err.result.error.code == 401 || (err.result.error.code == 403) &&
            (err.result.error.status == "PERMISSION_DENIED")) {
  
          // The access token is missing, invalid, or expired, prompt for user consent to obtain one.
          await new Promise((resolve, reject) => {
            try {
              // Settle this promise in the response callback for requestAccessToken()
              tokenClient.callback = (resp) => {
                if (resp.error !== undefined) {
                  reject(resp);
                }
                // GIS has automatically updated gapi.client with the newly issued access token.
                resolve(resp);
              };
              tokenClient.requestAccessToken();
            } catch (err) {
              console.log(err)
            }
          });
        } else {
          // Errors unrelated to authorization: server errors, exceeding quota, bad requests, and so on.
          throw new Error(err);
        }
      }
  
      function loadCalendar() {
        const tomorrow = new Date();
        tomorrow.setDate(tomorrow.getDate() + 1);
        tomorrow.setHours(0, 0, 0, 0);
  
        const after_tomorrow = new Date();
        after_tomorrow.setDate(after_tomorrow.getDate() + 2);
        after_tomorrow.setHours(0, 0, 0, 0);
  
        var calendar_query = { 'calendarId': 'primary', 'timeMin': tomorrow.toISOString(), 'timeMax' : after_tomorrow.toISOString(), 'singleEvents': true, 'orderBy': 'startTime'};
  
        // Try to fetch a list of Calendar events. If a valid access token is needed,
        // prompt to obtain one and then retry the original request.
        gapi.client.calendar.events.list(calendar_query)
        .then(calendarAPIResponse => CALENDAR_EVENTS = JSON.stringify(calendarAPIResponse))
        .catch(err  => getToken(err))  // for authorization errors obtain an access token
        .then(retry => gapi.client.calendar.events.list(calendar_query))
        .then(calendarAPIResponse => CALENDAR_EVENTS = JSON.stringify(calendarAPIResponse))
        .catch(err  => console.log(err));   // cancelled by user, timeout, etc.
      }
      
      // call loadCalendar after 3 seconds so that gapi.client initiates connection
      setTimeout(loadCalendar, 10000);
  
    </script>

• Now once everything is loaded, the client connects the Arduino and p5.js by simply clicking on the screen and selecting the Arduino port. From now on, everything gets triggered once the button is pressed.
• Green button – goodMorning function gets called.
  1) Load Gmail information about unread emails
  2) Clear up the saved array, leaving only the necessary information to display
  3) P5.speech libraries voices over the amount emails received, the subject, and the sender info of each one as well. Upon completion, Mozart’s Eine kleine Nachtmusik classical music starts playing.

  /* voices over the Good Morning mode*/
  function goodMorning() {
    // load the unread emails
    loadGmail();
  
    // timeout to wait till the above functions finishes execution
    setTimeout(function() {
      clearEmails();
    }, 2000);
  
    setTimeout(function() {
      myVoice.speak(GM_PHRASES[Math.floor(Math.random()*GM_PHRASES.length)] + "You've got " + emails.length + " emails while you were sleeping.");
      if (emails.length === 0) {
        return;
      }
      emails.forEach((email, index) => {
        setTimeout(function() {
          console.log(numberMapping[index + 1] + ' email is from ' + email.from + ' about ' + email.subject); // -> debug
          myVoice.speak(numberMapping[index + 1] + ' email is from ' + email.from + ' about ' + email.subject);
        }, (index + 1) * 10000); // wait for the previous voice to finish before starting next one
      });
      setTimeout(function() {
        myVoice.speak("Turning on music!");
      }, (emails.length + 1) * 10000);
      setTimeout(function() {
        playMusic();
      }, (emails.length + 1) * 10000 + 3000); // wait till events finishes voicing and the previous line too.
    }, 6000); // this timer is the sum of the before called timers (1000 + 3000) + 1000 extra miliseconds
  }

• Blue button – goodNight function gets called.
  1) Clear up the saved calendar events, leaving only necessary information to display
  2) Voice over the number of events and the time the alarm is set to.
  3) Voice over each of the events, time, and location

  /* voices over the events happening tomorrow*/
  function goodNight() {
    events = clearEvents();
    setTimeout(function() {
      const eventsLength = events.length - 1;
      let p = "Tomorrow you have " + eventsLength + " events. Your alarm is set to " + events[0]['startTime']+ " AM. " + GN_PHRASES[Math.floor(Math.random()*GN_PHRASES.length)];
      myVoice.speak(p);
      // console.log(p);
    }, 1500);
  
    // iterate thoruhg events and voice them over
    // timeout used since forEach does not wait for the voice to finish which gives undesired output
    for (let index = 1; index < events.length; index++) {
      const event = events[index];
      setTimeout(function() {
        console.log(numberMapping[index] + ' event is ' + event['eventName'] + ', happening from ' + event['startTime'] + ' till ' + event['endTime'] + ' at ' + event['location']);
        myVoice.speak(numberMapping[index] + ' event is ' + event['eventName'] + ', happening from ' + event['startTime'] + ' till ' + event['endTime'] + ' at ' + event['location']);
      }, index * 13000);
    }
  }