Magic Picture of Storm at Sea

/* Copyright 2021 Lincoln D. Stein <lincoln.stein@gmail.com> */

#include <pcmConfig.h>
#include <TMRpcm.h>
#include <pcmRF.h>
#include <FastLED.h>

#include <SPI.h>
#include <SD.h>
#include <L298N.h>

// Date and time functions using a DS3231 RTC connected via I2C and Wire lib
#include <RTClib.h>

#include "script.h"
#include "ship_pins.h"

// this controls the granularity of lighting transitions - higher is more gradual
#define GRADIENT_SIZE 20

// Create one motor instance
L298N motor(M_EN, M_IN1, M_IN2);

// real time clock
RTC_DS3231 Clock;

// uncomment this to set the clock at compile time
// #define SET_CLOCK 1

// This is an array of leds.  One item for each led in your strip.
CRGB argb[NUM_LEDS];

// Audio
TMRpcm audio;

// state variables
byte Leds           = 0;
byte Sleeping       = 0;
byte MastLightState = 0;
unsigned long int  StormTime = 0;
unsigned long int  GullTime  = 0;
unsigned long int  RTCTime   = 0;
unsigned long int  MastBlinkTime = 0;

// tilt sensor state
byte last_button_state = LOW;
byte ButtonState       = LOW;
unsigned long int last_debounce_time = 0;

void setup() {
  char wavFile[15];
  Wire.begin();

  FastLED.addLeds<WS2812B, LED_STRIP_PIN, GRB>(argb, NUM_LEDS);

  pinMode(SD_Pin, OUTPUT);
  digitalWrite(SD_Pin, HIGH);

  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);

  // use internal button pullup for tilt sensor
  pinMode(TILT_PIN, INPUT_PULLUP);

  Serial.begin(9600);

  if (!SD.begin(SD_Pin)) {
    Serial.println(F("SD fail"));
    Serial.flush();
    abort();
  }

  if (!Clock.begin()) {
    Serial.println(F("Couldn't find RTC module"));
    Serial.flush();
    abort();
  }

  if (Clock.lostPower()) {
    Serial.println(F("Clock lost power. Resetting time"));
    Clock.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
#ifdef SET_CLOCK
  Clock.adjust(DateTime(F(__DATE__), F(__TIME__)));
#endif

  Serial.println();

  audio.speakerPin = Speaker_Pin;
  audio.quality(1);
  audio.loop(0);
  audio.setVolume(3);
  audio.play(strcpy_P(wavFile, (char*)pgm_read_word(&(Bells[1]))));

  // initial lighting
  Leds = 0;
  updateShiftRegister();
  change_lighting(DAYLIGHT);

  StormTime = INITIAL_STORM_PAUSE - TIME_BETWEEN_STORMS; // this forces the storm to start 30 seconds after turning on
  GullTime = millis();

#if DEBUG
  Serial.print(F("StormTime = "));
  Serial.print(StormTime);
  Serial.print(F(" millis() = "));
  Serial.println(millis());
#endif

  randomSeed(analogRead(A1)); // analogRead on unconnected pin to give a random seed

}

void loop() {
  char wavFile[15];

  byte sleeping = is_sleeping();

  if (millis() - MastBlinkTime > MAST_BLINK_INTERVAL) {
    MastLightState = !MastLightState;
    set_mast_light(MastLightState);
    MastBlinkTime = millis();
  }

  if (!sleeping) {
    if (millis() - StormTime > TIME_BETWEEN_STORMS) {
#if DEBUG
      Serial.println(F("Storm starting"));
#endif
      do_storm();
      StormTime = millis();
    }

    if (millis() - GullTime > random(AVERAGE_GULL_INTERVAL - GULL_INTERVAL_RANGE, AVERAGE_GULL_INTERVAL + GULL_INTERVAL_RANGE)) {
#if DEBUG
      Serial.println(F("Gulls squawking"));
#endif
      audio.setVolume(4);
      audio.play(strcpy_P(wavFile,
                          (char*)pgm_read_word(&(Gulls[random(0, sizeof(Gulls) / sizeof(Gulls[0]))]
                                                ))));
      GullTime = millis();
    }
  }
}

void do_storm() {
  char wavFile[15];
  byte EventCounter = 0;
  byte done         = 0;
  long int now = millis();

  while (!done) {
    long int time_elapsed = millis() - now;
    byte tilt = tilt_changed(); // have to keep monitoring this in order to update ButtonState
#if DEBUG
    if (tilt) {
      Serial.print(F("Tilt state changed to "));
      Serial.println(ButtonState, DEC);
    }
#endif

    if (StormScript[EventCounter].millis <= time_elapsed) { // time to do an event!
#if DEBUG
      Serial.print(F("** Event "));
      Serial.print(EventCounter);
      Serial.println(F(" **"));
      Serial.print(F("Relative Time = "));
      Serial.print(time_elapsed);
      Serial.print(F("; Script time = "));
      Serial.println(StormScript[EventCounter].millis);
      Serial.print(F("Action = "));
      Serial.println(StormScript[EventCounter].action);
      Serial.print(F("Value = "));
      Serial.println(StormScript[EventCounter].value, DEC);
#endif

      int value = StormScript[EventCounter].value;
      switch (StormScript[EventCounter].action) {

        case stormsound :
          while (audio.isPlaying()) {
            delay(10);
          }
          audio.setVolume(5);
          audio.play(strcpy_P(wavFile, stormfile));
          break;

        case light_transition :
          change_lighting(value);
          break;

        case lightning :
          flash_lightning((Lightning)value);
          break;

        case motor_speed :
          set_motor_speed(value);
          break;

        case mast_light_transition :
          set_mast_light(value);
          break;

        case ending :
          while (audio.isPlaying()) {
            delay(10);
          }
          done++;
          break;
      }
      EventCounter++;
    }
  }
}

void set_motor_speed (int value) {
  if (value == 0) {
    // motor.stop();
    stop_when_horizontal(motor);
  } else {
    motor.setSpeed(value);
    motor.forward();
  }
}

void change_lighting (int v) {
  byte arrSize = sizeof(LightingEffects) / sizeof(LightingEffects[0]);
  if (v >= arrSize) {
#if DEBUG
    Serial.print(F("BUG: change_lighting called with value of "));
    Serial.print(v, DEC);
    Serial.print(F(". But end of array is at "));
    Serial.println(arrSize - 1, DEC);
#endif
    return;
  }
  CRGB color = LightingEffects[v];
  fade_to_color(color);
}

void flash_lightning (Lightning v) {
  int led, rgb;
  int previous_color = argb[0];

  if (v == center) {
    big_flash();
    return;
  }

  if (v == left) {
    led = LEFT_LED;
    rgb = 0;
  } else if (v == right) {
    led = RIGHT_LED;
    rgb = NUM_LEDS - 1;
  } else {
    return;
  }

  for (uint8_t i = 0; i < 10; i++) {
    bitSet(Leds, led);
    updateShiftRegister();
    argb[rgb] = LIGHTNING_COLOR;
    FastLED.show();

    delay(random(0, 10));

    bitClear(Leds, led);
    updateShiftRegister();
    argb[rgb] = previous_color;
    FastLED.show();

    delay(random(0, 50));
  }
}

void big_flash() {
  CRGB current = argb[1];
  for (uint8_t i = 0; i < 10; i++) {
    fill_solid(argb, NUM_LEDS, LIGHTNING_COLOR);
    FastLED.show();
    delay(random(0, 10));
    fill_solid(argb, NUM_LEDS, current);
    FastLED.show();
    delay(random(0, 50));
  }
}


void set_mast_light(int on) {
  if (on) {
    bitSet(Leds, MAST_LED);
  } else {
    bitClear(Leds, MAST_LED);
  }
  updateShiftRegister();
}

void updateShiftRegister()
{
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, Leds);
  digitalWrite(latchPin, HIGH);
}

void fade_to_color(CRGB destination) {
  CRGB CurrentSky = argb[1];
  CRGB gradient[GRADIENT_COUNT];
  int pause_time = FADE_DURATION / GRADIENT_COUNT;
  fill_gradient_RGB(gradient, 0, CurrentSky, GRADIENT_COUNT - 1, destination);
  for (int i = 0; i < GRADIENT_COUNT; i++) {
    fill_solid(argb, NUM_LEDS, gradient[i]);
    FastLED.show();
    delay(pause_time);
  }
  CurrentSky = destination;
}

// check for bedtime
byte is_sleeping() {
  char wavFile[15];

  if ((RTCTime == 0) || (millis() - RTCTime > CHECK_RTC_INTERVAL)) {
    RTCTime = millis();
    byte hr = get_hour();
#if DEBUG
    Serial.print(F("Checking clock...hr="));
    Serial.println(hr, DEC);
#endif

    if ((hr >= SLEEP_START) || (hr <= SLEEP_END)) {
#if DEBUG
      Serial.println(F("In sleep range"));
#endif
      if (!Sleeping) {
#if DEBUG
        Serial.println(F("It's late. Nighty night!"));
#endif
        audio.play(strcpy_P(wavFile, (char*)pgm_read_word(&(Bells[0]))));
        change_lighting(NIGHTLIGHT);
        Sleeping = TRUE;
      }
    }

    else { // wake up!
      if (Sleeping) {
#if DEBUG
        Serial.println(F("Good morning! Waking up"));
#endif
        change_lighting(DAYLIGHT);
        audio.play(strcpy_P(wavFile, (char*)pgm_read_word(&(Bells[1]))));
        Sleeping = FALSE;
        StormTime = millis();
        GullTime = millis();
      }
    }
  }

  return Sleeping;
}

/* method for calculating DST offset copied from here: https://forum.arduino.cc/t/ds3231-rtc-daylight-savings-time/410699/4 */
int get_hour () {
  DateTime now = Clock.now();
  boolean DST  = 0;

  // ********************* Calculate offset for Sunday *********************
  byte y    = now.year();           // DS3231 uses two digit year (required here)
  byte x = (y + y / 4 + 2) % 7;     // remainder will identify which day of month DST starts on

  byte hour  = now.hour();
  byte month = now.month();
  byte dom   = now.day();

  // LS: this code is inelegant, but it purportedly works, so I'm not going to mess with it
  // is Sunday by subtracting x from the one
  // or two week window. First two weeks for March
  // and first week for November
  // *********** Test DST: BEGINS on 2nd Sunday of March @ 2:00 AM *********
  if (month == 3 && dom == (14 - x) && hour >= 2)   {
    DST = 1;
  }
  if ((month == 3 && dom > (14 - x)) || month > 3)  {
    DST = 1;
  }
  // ************* Test DST: ENDS on 1st Sunday of Nov @ 2:00 AM ************
  if (month == 11 && dom == (7 - x) && hour >= 2)  {
    DST = 0; // daylight savings time is FALSE (Standard time)
  }
  if ((month == 11 && dom > (7 - x)) || month > 11 || month < 3)  {
    DST = 0;
  }

  if (DST) // Test DST and add one hour if = 1 (TRUE)
    return hour + 1;
  else
    return hour;
}

/* Tilt sensor routines */

void stop_when_horizontal (L298N m, int timeout) {
  unsigned long timestart = millis();
  boolean  timedout = false;

#if DEBUG
  Serial.println(F("Waiting for horizontal before stopping"));
#endif
  while (!timedout) {
    if (tilt_changed()) {
      if (ButtonState == LOW)
        break;
    }
    timedout = millis() - timestart > timeout;
  }
  if (timedout)
    Serial.println(F("Timed out waiting for horizontal"));
  else
    Serial.println(F("Stopped normally"));
  m.stop();
}

boolean tilt_changed() {
  byte reading = digitalRead(TILT_PIN);
  boolean changed = false;

  if (reading != last_button_state) {
    last_debounce_time = millis();
  }

  if (millis() - last_debounce_time > DEBOUNCE_DELAY) {
    if (reading != ButtonState) {
      changed    = true;
      ButtonState = reading;
    }
  }
  last_button_state = reading;
  return changed;
}