The Talking Alarm Clock

// ================================================================================================
// Project: Talking Alarm Clock by ABEtronics 2018.
// Date:    5-6-18 v1.00
// Author:  Jim Abraham
//-------------------------------------------------------------------------------------------------
// WIZ750SR-232            (ETHERNET TO SERIAL INTERFACE)
// Arduino MEGA 2560 Rev3  (CONTROL BOARD)
// GEN4-uLCD-32PT          (LCD DISPLAY)
// MP3 Shield              (MP3 player)
// RTC Deadon              (Real Time Clock)
// ================================================================================================
// ------------------------------------------------------------------------------
// Set-Up Libraries
// ------------------------------------------------------------------------------
#include <SPI.h>            // SPI library
#include <SdFat.h>          // SDFat Library
#include <SdFatUtil.h>      // SDFat Util Library
#include <SFEMP3Shield.h>   // Mp3 Shield Library
#include <genieArduino.h>   // LCD Library
// ------------------------------------------------------------------------------
Genie genie;
SdFat sd;                   // Create object to handle SD functions
SFEMP3Shield MP3player;     // Create MP3 library object
// ------------------------------------------------------------------------------
// Initialize Variables
// ------------------------------------------------------------------------------
// REAL TIME CLOCK (RTC)
// ------------------------------------------------------------------------------
int RTC_SEC = 0;
int RTC_MIN = 0;
int RTC_HR = 0;
int RTC_AMPM = 0;
int RTC_MON = 0;
int RTC_DAY = 0;
int RTC_YR = 0;
int rtc_cs = 53; //RTC chip select.
int S_day = 0;
int S_month = 0;
int S_year = 18;
int SEC = 0;
int MIN = 0;
int HR = 0;
int AMPM = 0;
int ap = 0;
int tti = 0;
int hris = 0;
int minis = 0;
int ampmis = 0;
// ------------------------------------------------------------------------------
// LCD
// ------------------------------------------------------------------------------
int background;
int background_prev = 8;
int wakeupscreen;
int LCD_CLR = 0;
// ------------------------------------------------------------------------------
// ALARMING
// ------------------------------------------------------------------------------
int Set_WU_Alarm = 0;
int WAKE_UP_JACK = 0;
int TEST_Wakeup_Alarm = 0;
int Snooze_MIN = 0;
int Snooze_HR = 0;
int Snooze_PB = 0;
int Snooze_PB_PRESSED = 0;
int setAlarmPB_release = 0;
int SnoozePB_release = 0;
int SnoozePB_alarm_release = 0;
int MIN_ALARM = 0;
int HR_ALARM = 0;
int HR_ALARM1 = 0;
int AMPM_ALARM = 0;
int x = 0;
int PB_PRESSED_release = 0;
// ------------------------------------------------------------------------------
// MP3
// ------------------------------------------------------------------------------
int vol = 0;
int vol_alarm = 0;
int alarm_flag = 0;
int alarm_track;
int good_day = 0;
int hand = 0;
int pmp3f = 0;
int song = 150;
int BL = 150;
int announce_hourly;
int announce_TOH = 0;
int announce_TOH1=0;
// ------------------------------------------------------------------------------
// Set-Up I/O Pin Mapping and Function.
// ------------------------------------------------------------------------------
//Digital I/O Pins:
// D48 - IN   alarm/snooze pb
// D49 - OUT  alarm/snooze pb light
// D10 - OUT  Reset the LCD
//------------------------------------------------------------------
int SnoozePB = 48;
int snoozepbled = 49;
int LCD_Reset = 10;
int Test_LED13 = 13;
int WIZ750SR_nReset=46;

// ================================================================================================
// SETUP ROUTINE
// ================================================================================================
void setup()
{
  // ------------------------------------------------------------------------------
  // Set-Up I/O Pins:
  // ------------------------------------------------------------------------------
  // Set-Up Input Pins
  //-------------------------------------------------------------------------------
  // Use Snooze/Alarm PB:
  // - To set alarm on/off press for 2 seconds.
  // - When alarming press to snooze. (7 min alarm trigger)
  // - When not in alarm mode press to announce time.
  // ------------------------------------------------------------------------------
  pinMode(SnoozePB, INPUT_PULLUP);
  // ------------------------------------------------------------------------------
  // Set-Up Output Pins
  // ------------------------------------------------------------------------------
  pinMode(snoozepbled, OUTPUT);     // PB LIGHT
  pinMode(rtc_cs, OUTPUT);          // RTC chip select
  pinMode(LCD_Reset, OUTPUT);       // Set D10 on Arduino to Output (Display Reset)
  pinMode(Test_LED13, OUTPUT);      // Test LED
  pinMode(WIZ750SR_nReset, OUTPUT); // Reset WIZ750SR Module

  // ------------------------------------------------------------------------------
  // Set-Up Serial Ports
  // ------------------------------------------------------------------------------
  // #0 serial communication for PC 9600,8N1
  // ------------------------------------------------------------------------------
  Serial.begin(9600);       // PC

  // ------------------------------------------------------------------------------
  // #1 serial communication for WIZNET board (serial to ethernet) 9600,8N1
  // ------------------------------------------------------------------------------
  Serial1.begin(9600);      // WIZ750SR-232

  // ------------------------------------------------------------------------------
  // #2 serial communication for LCD DISPLAY 115200,8N1
  // ------------------------------------------------------------------------------
  Serial2.begin(115200);    // GEN4-uLCD-32PT.
  genie.Begin(Serial2);     // Use Serial1 for talking to the Genie Library, and to the 4D Systems display
  genie.AttachEventHandler(myGenieEventHandler); // Attach the user function Event Handler for processing events

  // ------------------------------------------------------------------------------
  // Reset the Display.
  // THIS IS IMPORTANT AND CAN PREVENT OUT OF SYNC ISSUES, SLOW SPEED RESPONSE ETC
  // If NOT using a 4D Arduino Adaptor, digitalWrites must be reversed as Display Reset is Active Low,
  // and the 4D Arduino Adaptors invert this signal so must be Active High.
  // ------------------------------------------------------------------------------
  digitalWrite(LCD_Reset, 0);         // Reset the Display via D10
  digitalWrite(WIZ750SR_nReset, 0);   // Reset WIZ750SR (ative low)
  delay(100);
  digitalWrite(LCD_Reset, 1);         // unReset the Display via D10
  delay(1000);
  digitalWrite(WIZ750SR_nReset, 1);   // Remove reset signal from WIZ750SR
  delay (2500);                       // Let the display start up after the reset
  digitalWrite(Test_LED13, 0);

  // ------------------------------------------------------------------------------
  // Initialize the RTC.
  // ------------------------------------------------------------------------------
  RTC_init();
  
  // ------------------------------------------------------------------------------
  // Initialize the SD card and checks for errors.
  // ------------------------------------------------------------------------------
  Sd_init();
  
  // ------------------------------------------------------------------------------
  // Initialize Functions
  // ------------------------------------------------------------------------------
  Snooze_PB = 0;
  Snooze_MIN = 0;
  pmp3f = 4;               // Stop Playing mp3 alarm track.
  SilenceAlarm();
  Read_RTC_Alarm_Time();   // Get stored alarm time, vol, track
  Read_RTC_SRAM();         // Get background, wakeup screen, announce hourly values.
  Read_Display_Time();     // Read Date and time and display on LCD.
  delay(1000);
  
  // ------------------------------------------------------------------------------
  //Initialize the MP3 Player Shield.
  // ------------------------------------------------------------------------------
  MP3_init();
  // ------------------------------------------------------------------------------
}//SETUP ROUTINE END

// ================================================================================================
// MAIN LOOP
// ================================================================================================
void loop()
{
  Read_Display_Time();    // Read Date and time and display on LCD.
  Announce_Hourly();      // Announce the top of the hour.
  Check_Serial_Com();     // Check for serial commands.
  Check_PB_Status();      // Check Pushbutton Status.
  WakeUpJackie();         // Check if alarm set to wake up Jackie.
  Check_MP3_Player();     // Check if track needs to be played.
}
//MAIN LOOP END
// ================================================================================================

// ================================================================================================
// INITIALIZING ROUTINES
// ================================================================================================
// ------------------------------------------------------------------------------
//Initialize the LCD.
// ------------------------------------------------------------------------------
void LCD_init()
{
  // Change background and text that was selected.
  if (background == 1) {genie.WriteObject(GENIE_OBJ_FORM, 0, 1);}
  if (background == 2) {genie.WriteObject(GENIE_OBJ_FORM, 1, 1);}
  if (background == 3) {genie.WriteObject(GENIE_OBJ_FORM, 2, 1);}
  if (background == 4) {genie.WriteObject(GENIE_OBJ_FORM, 3, 1);}
}

// ------------------------------------------------------------------------------
// Set-Up RTC
// ------------------------------------------------------------------------------
//day(1-31), month(1-12), year(0-99), hour(0-23), minute(0-59), second(0-59)
//SetTimeDate(28,10,14,11,59,50);
// ------------------------------------------------------------------------------
int RTC_init()
{
  // start the SPI library:
  SPI.begin();
  SPI.setBitOrder(MSBFIRST);
  SPI.setDataMode(SPI_MODE3); //mode 3 works
  //set control register
  digitalWrite(rtc_cs, 0);
  SPI.transfer(0x8E); //control reg
  SPI.transfer(0x37); //37=00100101, 60= disable Osciallator and Battery SQ wave @1hz, temp compensation, Alarms disabled
  digitalWrite(rtc_cs, 1);
  delay(10);
}

// ------------------------------------------------------------------------------
// initSD() initializes the SD card and checks for an error.
// ------------------------------------------------------------------------------
void Sd_init()
{
  if (!sd.begin(SD_SEL, SPI_FULL_SPEED)) sd.initErrorHalt();
  // depending upon your SdCard environment, SPI_HALF_SPEED may work better.
  if (!sd.chdir("/")) sd.errorHalt("sd.chdir");
}

// ------------------------------------------------------------------------------
//Initialize the MP3 Player Shield
// ------------------------------------------------------------------------------
void MP3_init()
{
  uint8_t result = MP3player.begin();
  // set speaker volume and play start-up mp3 file.
  MP3player.setVolume(0, 0);        //set new volume. 0=max, 255=lowest (off)
  MP3player.setMonoMode(0);         //set Stereo Output.
  MP3player.playTrack(225);         //Play "Hello"
  delay(1500);                      //wait
  MP3player.playTrack(224);         //Play "system Ready"
  delay(1000);                      //wait
}
// ================================================================================================
// ROUTINES
// ================================================================================================
// ------------------------------------------------------------------------------
// Check Pushbutton Status
// ------------------------------------------------------------------------------
void Check_PB_Status()
{
// PB pressed = low
// alarm not enabled - when pressed and held for 3 seconds turn-on alarm.
// alarm not enabled - when pressed announce time.
// alarm enabled - when pressed snooze alarm enabled.
// alarm enabled - when pressed and held for 3 seconds turn-off alarm.
// ------------------------------------------------------------------------------

// ------------------------------------------------------------------------------
// alarm not enabled - when pressed and held for 3 seconds turn-on alarm.
// alarm not enabled - when pressed announce time.
// Set_WU_Alarm == 0 Wake up alarm disabled.
// ------------------------------------------------------------------------------
 if ((digitalRead(SnoozePB) == LOW) && (PB_PRESSED_release == 0))
 {
      if (Set_WU_Alarm == 0)
        {
           PB_PRESSED_release = 1;
           x = 0;
          do
          {
            delay(50);
            x = x + 1;
            if (x >= 20) {break;} // pb held down for 2 seconds.
          } while (digitalRead(SnoozePB) == LOW);
      
          if (digitalRead(SnoozePB) == HIGH)    // Announe Time
          {
            Snooze_PB_PRESSED = 3;
            Announce_Time();
            return;
        }
        if (digitalRead(SnoozePB) == LOW)      // Turn On Alarm
        {
          Enable_Wakeup_Alarm();
          return;
        } 
      }

// ------------------------------------------------------------------------------
// alarm enabled - when pressed snooze alarm enabled.
// alarm enabled - when pressed and held for 3 seconds turn-off alarm. 
// ------------------------------------------------------------------------------
    if (Set_WU_Alarm == 1)
        {
          PB_PRESSED_release = 1;
          x = 0;
          do
          {
            delay(50);
            x = x + 1;
            if (x >= 20) {break;} // pb held down for 2 seconds.
          } while (digitalRead(SnoozePB) == LOW);
      
          if (digitalRead(SnoozePB) == HIGH)    // Announce or Snooze
          {
            Snooze_PB_PRESSED = 3;
            if(!MP3player.isPlaying())  // Announce
            {
              Announce_Time();
              return;
            }  
            if(MP3player.isPlaying())   // Snooze
            { 
              Snooze_Alarm();
              return;
            }   
          }
          if (digitalRead(SnoozePB) == LOW)   // Turn Off Alarm
          {
            Disable_Wakeup_Alarm();
            return;
          } 
        }     
  }
// ------------------------------------------------------------------------------
 if (digitalRead(SnoozePB) == HIGH) {PB_PRESSED_release = 0;}
}

// ------------------------------------------------------------------------------
// Read RTC and Display Time on LCD
// ------------------------------------------------------------------------------
void Read_Display_Time()
{
  if (!MP3player.isPlaying())
  {
    ReadTimeDate();
  }
}

// ------------------------------------------------------------------------------
// Announce the current time when Snooze PB pressed or Top of the Hour.
// ------------------------------------------------------------------------------
void Announce_Time()
{
  if (announce_TOH == 1 || Snooze_PB_PRESSED == 3)
    {  
    Snooze_PB_PRESSED = 0;
    announce_TOH = 0;
    Read_Display_Time();
    HR = RTC_HR;
    MIN = RTC_MIN;
    AMPM = ap;
    tti = 0;
    hris = 0;
    minis = 0;
    ampmis = 0;
    hand = 0;
    MP3player.setVolume(0, 0);
    good_day = 0;
    // good morning =    220
    // good afternoon =  221
    // good evening =    222
    // good night =      223
    // AM = Good Morning.
    // PM & 12-5 Good Afternoon.
    // PM & 6-9 Good Evening.
    // PM & 10-11 Good Night.
    if (AMPM == 1)
    {
      MP3player.playTrack(220);            //Good Morning.
      good_day = 1;
    }
    if ((AMPM == 2) && ((HR == 12) || (HR == 1) || (HR == 2) || (HR == 3) || (HR == 4) || (HR == 5)))
    {
      MP3player.playTrack(221);           //Good Afternoon
      good_day = 1;
    }
    if ((AMPM == 2) && ((HR == 6) || (HR == 7) || (HR == 8) || (HR == 9)))
    {
      MP3player.playTrack(222);           //Good Evening
      good_day = 1;
    }
    pmp3f = 1;                            //play mp3 files flag
    playmp3();
    }
}

// ------------------------------------------------------------------------------
//Announce Top of the Hour Time. (Change display and announce)
// ------------------------------------------------------------------------------
void Announce_Hourly()
{
  if (announce_hourly == 1 && RTC_MIN == 0)
  {
    if (RTC_SEC == 0 && announce_TOH1==0)
    {
      announce_TOH1=1;
      genie.WriteObject(GENIE_OBJ_FORM, 7, 1);
      genie.WriteObject(GENIE_OBJ_LED_DIGITS, 0x12, RTC_HR);
      //RTC 1=AM, 2=PM
      if (ap == 1) {genie.WriteObject(GENIE_OBJ_STRINGS, 0x09, 1);} // LCD PM=0, AM=1
      if (ap == 2) {genie.WriteObject(GENIE_OBJ_STRINGS, 0x09, 0);} // LCD PM=0, AM=1
      announce_TOH = 1;
      Announce_Time();
    }
    if (!MP3player.isPlaying() && pmp3f==0 && announce_TOH1==1)
      {
        announce_TOH1=0;
        LCD_init();
      }
  }
}

// ------------------------------------------------------------------------------
// Check if ready to wake up Jackie.
// ------------------------------------------------------------------------------
void WakeUpJackie()
{
  if (Set_WU_Alarm == 1)
  {
    if (alarm_flag == 0)
    {
      CheckAlarmTime();                                // check if RTC alarm bit set.

      if (WAKE_UP_JACK == 1 || TEST_Wakeup_Alarm == 1) // If alarm bit set, play alarm.
      {
        if (!MP3player.isPlaying())
        {
          MP3player.setVolume(0, 0); // set new volume. 0=max, 255=lowest (off)
          MP3player.playTrack(alarm_track);    // Play Alarm Track 1st time.
          Snooze_PB = 1;
          digitalWrite(snoozepbled, 1);        // Turn on Snooze pb LED.
          alarm_flag = 1;                      // Alarm played.
          TEST_Wakeup_Alarm = 0;
          if (wakeupscreen == 1) {genie.WriteObject(GENIE_OBJ_FORM, 5, 1);}
          if (wakeupscreen == 2) {genie.WriteObject(GENIE_OBJ_FORM, 4, 1);}
          if (wakeupscreen == 3) {genie.WriteObject(GENIE_OBJ_FORM, 6, 1);}
        }
      }
    }
    else
    {
      if ((Snooze_PB == 3) && (Snooze_MIN == RTC_MIN))
      {
        if (!MP3player.isPlaying())
        {
          MP3player.setVolume(0, 0); // set new volume. 0=max, 255=lowest (off)
          MP3player.playTrack(alarm_track);         //Play Alarm Track AGAIN.
          Snooze_PB = 2;
          digitalWrite(snoozepbled, 1);             //Turn on Snooze pb LED.
          if (wakeupscreen == 1) {genie.WriteObject(GENIE_OBJ_FORM, 5, 1);}
          if (wakeupscreen == 2) {genie.WriteObject(GENIE_OBJ_FORM, 4, 1);}
          if (wakeupscreen == 3) {genie.WriteObject(GENIE_OBJ_FORM, 6, 1);}
        }
      }
    }
  }
}

// ------------------------------------------------------------------------------
// Snooze Alarm?
// Snooze_PB
// = 1 play alarm track 1st time.
// = 2 play alarm track after snooze pb pressed and 7 in later.
// = 3 snooze pb pressed.
// ------------------------------------------------------------------------------
void Snooze_Alarm()
{
    LCD_init();
    MP3player.stopTrack();     // Stop Track
    pmp3f = 0;
    Read_Display_Time();
    Snooze_MIN = RTC_MIN + 7;  // + 7 minutes more to snooze!!
    if (HR_ALARM1 == 0) {
      Snooze_HR = HR_ALARM;
    }
    if (Snooze_MIN > 60)
    {
      Snooze_MIN = Snooze_MIN - 60;
      Snooze_HR = HR_ALARM + 1;
      HR_ALARM1 = 1;
    }
    if (Snooze_MIN == 60) {
      Snooze_MIN = 0;
    }
    if (Snooze_HR > 12) {
      Snooze_HR = Snooze_HR - 12;
    }
    Snooze_PB_PRESSED = 1;
    Snooze_PB = 3;
    pmp3f = 4;                //Stop Playing mp3 alarm track.
    //day(1-31), month(1-12), year(0-99), hour(0-23), minute(0-59), second(0-59)
    SetAlarmTime(Snooze_HR, Snooze_MIN, AMPM_ALARM, alarm_track, 0);
}

// ------------------------------------------------------------------------------
// Play MP3 file if commanded.
// ------------------------------------------------------------------------------
void Check_MP3_Player() {
  if (pmp3f > 0) playmp3();
}

// ------------------------------------------------------------------------------
// Write data to RTC SRAM.
// ------------------------------------------------------------------------------
int WriteBackgroundtoRTC(int bg)
{
  // ------------------------------------------
  // Write background # to SRAM
  // ------------------------------------------
  digitalWrite(rtc_cs, LOW);
  SPI.transfer(0x098);                // write 5 address to address reg 98H
  SPI.transfer(5);
  digitalWrite(rtc_cs, HIGH);
  delay(10);
  digitalWrite(rtc_cs, LOW);
  SPI.transfer(0x99);                // write data to address 5 via 99h data addres
  SPI.transfer(bg);                  // 1-4
  digitalWrite(rtc_cs, HIGH);
  delay(10);
}
int WriteWakeupScreentoRTC(int wus)
{
  // ------------------------------------------
  // Write Wake Up Screen # to SRAM
  // ------------------------------------------
  digitalWrite(rtc_cs, LOW);
  SPI.transfer(0x098);                // write 6 address to address reg 98H
  SPI.transfer(6);
  digitalWrite(rtc_cs, HIGH);
  delay(10);
  digitalWrite(rtc_cs, LOW);
  SPI.transfer(0x99);                // write data to address 6 via 99h data addres
  SPI.transfer(wus);                  // 1-3
  digitalWrite(rtc_cs, HIGH);
  delay(10);
}
int WriteAnnounceHourlytoRTC(int nh)
{
  // ------------------------------------------
  // Write Announce Hourly # to SRAM
  // ------------------------------------------
  digitalWrite(rtc_cs, LOW);
  SPI.transfer(0x098);                // write 7 address to address reg 98H
  SPI.transfer(7);
  digitalWrite(rtc_cs, HIGH);
  delay(10);
  digitalWrite(rtc_cs, LOW);
  SPI.transfer(0x99);                // write data to address 7 via 99h data addres
  SPI.transfer(nh);                  // 0-1
  digitalWrite(rtc_cs, HIGH);
  delay(10);
}

// ------------------------------------------------------------------------------
// check Serial communication: if chracter received
// ------------------------------------------------------------------------------
void Check_Serial_Com()
{
  if (Serial1.available() > 0)
  {
    getsercom(Serial1.read());    // get command from serial input
  }
}

// ------------------------------------------------------------------------------
// Check Serial Port for Incoming Characters
// ------------------------------------------------------------------------------
void getsercom(byte key_command)
{
  // MP3 file descriptions (track###.mp3 where ## = 000-255)
  // 1-59              1-59
  // 01-09             101 - 109
  // Alarm Tracks =    150 - 170
  // The Time Is =     200
  // AM =              201
  // PM =              202
  // have a nice day = 210
  // o-clock =         211
  // no =              219
  // good morning =    220
  // good afternoon =  221
  // good evening =    222
  // good night =      223
  // Sys Ready =       224
  // Hello =           225
  //-------------------------------------------------------------
  // Commands:
  // T = Announce Current Time  format: T,hr(1-12),min(1-59),ampm(1-2)
  //                                               min(0) say o-clock
  // H = Announce Current Time Hourly
  // h = Don't Announce Current Time Hourly
  // A = Enter Wake Up Alarm Time format: A,hr(1-12),min(1-59),ampm(1-2),track#,vol
  // P = Play Alarm MP3 Tracks    format: P,track#,vol
  // S = Stop Track               format: S
  // B = Backlight brightness     format: B,128-157 (not used)
  // E = Enable alarm mode.       format: E
  // D = Disable alarm mode.      format: D
  // ! = Test Alarm.              format: T (Play Alarm and disbale again)
  // 1 = background #1
  // 2 = background #2
  // 3 = background #3
  // 4 = background #4
  // 5 = wake up screen #1
  // 6 = wake up screen #2
  // 7 = wake up screen #3

  //--------------------------------------------------------------------------------------
  // Backgrounds
  //--------------------------------------------------------------------------------------
  if (key_command == '1')
  {
    Read_Display_Time();
    genie.WriteObject(GENIE_OBJ_FORM, 0, 1); // change startup screen (#,1 #=form#)
    background = 1;
    WriteBackgroundtoRTC(background);
    return;
  }
  if (key_command == '2')
  {
    Read_Display_Time();
    genie.WriteObject(GENIE_OBJ_FORM, 1, 1); // change startup screen (#,1 #=form#)
    background = 2;
    WriteBackgroundtoRTC(background);
    return;
  }
  if (key_command == '3')
  {
    Read_Display_Time();
    genie.WriteObject(GENIE_OBJ_FORM, 2, 1); // change startup screen (#,1 #=form#)
    background = 3;
    WriteBackgroundtoRTC(background);
    return;
  }
  if (key_command == '4')
  {
    Read_Display_Time();
    genie.WriteObject(GENIE_OBJ_FORM, 3, 1); // change startup screen (#,1 #=form#)
    background = 4;
    WriteBackgroundtoRTC(background);
    return;
  }

  //--------------------------------------------------------------------------------------
  // Wake Up Screens
  //--------------------------------------------------------------------------------------
  if (key_command == '5')
  {
    genie.WriteObject(GENIE_OBJ_FORM, 5, 1); // change startup screen (#,1 #=form#)
    wakeupscreen = 1;
    WriteWakeupScreentoRTC(wakeupscreen);
    return;
  }
  if (key_command == '6')
  {
    genie.WriteObject(GENIE_OBJ_FORM, 4, 1); // change startup screen (#,1 #=form#)
    wakeupscreen = 2;
    WriteWakeupScreentoRTC(wakeupscreen);
    return;
  }
  if (key_command == '7')
  {
    genie.WriteObject(GENIE_OBJ_FORM, 6, 1); // change startup screen (#,1 #=form#)
    wakeupscreen = 3;
    WriteWakeupScreentoRTC(wakeupscreen);
    return;
  }
  //--------------------------------------------------------------------------------------
  //  Enable/Disable Wake Up Alarm
  //--------------------------------------------------------------------------------------
  if (key_command == 'E'){Enable_Wakeup_Alarm();}
  if (key_command == 'D'){Disable_Wakeup_Alarm();}
  
  //--------------------------------------------------------------------------------------
  // Announce Hourly
  //--------------------------------------------------------------------------------------
  if (key_command == 'H')
  {
    announce_hourly = 1;
    WriteAnnounceHourlytoRTC(announce_hourly);
  }
  if (key_command == 'h')
  {
    announce_hourly = 0;
    WriteAnnounceHourlytoRTC(announce_hourly);
  }
  //--------------------------------------------------------------------------------------
  //  TEST Wake Up Alarm
  //--------------------------------------------------------------------------------------
  if (key_command == '!')
  {
    Enable_Wakeup_Alarm();
    TEST_Wakeup_Alarm = 1;
  }

  // ------------------------------------------------------------
  // Set Current Time
  // T, month, day, year, hr, min, sec, AmPm
  // ------------------------------------------------------------
  if (key_command == 'T')
  {
    tti = 0;
    hris = 0;
    minis = 0;
    ampmis = 0;
    hand = 0;
    pmp3f = 0;

    S_month = Serial1.parseInt();      // 1-12
    S_day = Serial1.parseInt();        // 1-31
    S_year = Serial1.parseInt();       // 20xx
    HR = Serial1.parseInt();           // 1-12
    MIN = Serial1.parseInt();          // 1-59, 60=OCLOCK
    SEC = Serial1.parseInt();          // 1-59, 60=OCLOCK
    AMPM = Serial1.parseInt();         // 1=AM, 2=PM
    vol_alarm = Serial1.parseInt();    // Alarm volume
    vol_alarm = 0;
    if (MIN >= 100)
    {
      MIN = MIN - 100;
      // ------------------------------------------------------------
      //day(1-31), month(1-12), year(0-99), hour(0-23), minute(0-59), second(0-59)
      // ------------------------------------------------------------
      SetTimeDate(S_day, S_month, S_year, HR, MIN, SEC);
      MIN = MIN + 100;
    } else
      // ------------------------------------------------------------
      //day(1-31), month(1-12), year(0-99), hour(0-23), minute(0-59), second(0-59)
      // ------------------------------------------------------------
    SetTimeDate(S_day, S_month, S_year, HR, MIN, SEC);
    Read_Display_Time();              //Read Date and time and display on LCD.
    UPDATE_LCD();

    pmp3f = 1;                        //Play mp3 files flag
    good_day = 1;
    MP3player.setVolume(0, 0);
    return;
  }
  // ------------------------------------------------------------
  // Set Wake Up Alarm Time
  // A = Set Wake Up Alarm Time format: A,hr(1-12),min(1-59),ampm(1-2)
  // ------------------------------------------------------------
  if (key_command == 'A')
  {
    tti = 0;
    hris = 0;
    minis = 0;
    ampmis = 0;
    hand = 0;
    pmp3f = 0;
    alarm_flag = 0;
    WAKE_UP_JACK = 0;
    HR = Serial1.parseInt();           // 1-12
    MIN = Serial1.parseInt();          // 1-59, 60=OCLOCK
    AMPM = Serial1.parseInt();         // 1=AM, 2=PM
    alarm_track = Serial1.parseInt();  // Alarm Track#
    vol_alarm = Serial1.parseInt();    // Alarm volume
    vol_alarm = 0;    // Alarm volume
    if (MIN==0 || MIN==59) {announce_hourly=0;}   // Turn off announce hourly is alarm min=0
    // ------------------------------------------------------------
    //Set Wake Up Alarm Time.
    // ------------------------------------------------------------
    HR_ALARM = HR;
    MIN_ALARM = MIN;
    AMPM_ALARM = AMPM;
    // ------------------------------------------------------------
    //day(1-31), month(1-12), year(0-99), hour(0-23), minute(0-59), second(0-59)
    // ------------------------------------------------------------
    SetAlarmTime(HR, MIN, AMPM, alarm_track, 0);
    WriteAlarmDatatoRTC(HR, MIN, AMPM, alarm_track, 0);
    UPDATE_LCD();
    pmp3f = 2;                                 //play mp3 files flag
    MP3player.setVolume(0, 0);
    playmp3();
    return;
  }

  // ------------------------------------------------------------
  // Sample Alarm MP3 Track
  // ------------------------------------------------------------
  if (key_command == 'P')
  {
    song = Serial1.parseInt();         //track #
    vol_alarm = Serial1.parseInt();    //Alarm volume
    vol_alarm = 0;
    if (song > 100)
    {
      pmp3f = 3;                      //play mp3 files flag
      MP3player.setVolume(0, 0);
      return;
    }
  }

  // ------------------------------------------------------------
  // Stop Track
  // ------------------------------------------------------------
  if (key_command == 'S')
  {
    pmp3f = 4;                  //play mp3 track flag
    return;
  }
}//end routine

// ------------------------------------------------------------------------------
// Play MP3 Files
// ------------------------------------------------------------------------------
void playmp3()
{
  // ------------------------------------------------------------
  // Play MP3 Files (Announce Current Time)
  // ------------------------------------------------------------
  if (pmp3f == 1 || pmp3f == 2)
  {
    if (!MP3player.isPlaying() && tti == 0)
    {
      tti = 1;
      MP3player.playTrack(200);                   // The Time is..
      delay(2000);
   }
   
    if (!MP3player.isPlaying() && tti == 1 && hris == 0)
    {
      hris = 1;
      MP3player.playTrack(HR);                   // Hour
    }
    if (!MP3player.isPlaying() && hris == 1 && minis == 0)
    {
      if (MIN == 0)
      {
        MP3player.playTrack(211);                  // O-Clock
        ampmis = 1;
        minis = 1;
      }
      if (MIN < 10)
      {
        MP3player.playTrack(100 + MIN);
        minis = 1;
      }
      if (MIN > 9)
      {
        MP3player.playTrack(MIN);                  // Minute
        minis = 1;
      }
    }
    if (!MP3player.isPlaying() && minis == 1 && ampmis == 0)
    {
      ampmis = 1;
      MP3player.playTrack(200 + AMPM);            // AM or PM (200+1 or 2)
    }

    if (!MP3player.isPlaying() && ampmis == 1 && hand == 0 && pmp3f == 1)
    {
      hand = 1;
      if (good_day == 1) {
        MP3player.playTrack(210); // Have a Good Day!
      }
      else {
        MP3player.playTrack(223); // Good Night.
      }
      pmp3f = 0;
    }
  }

  // ------------------------------------------------------------
  // Play MP3 Files (Play Alarm Track)
  // ------------------------------------------------------------
  if (pmp3f == 3)
  {
    if (!MP3player.isPlaying())
    {
      MP3player.playTrack(song);        //Play Alarm Track
      pmp3f = 0;
      return;
    }
  }
  // ------------------------------------------------------------
  // STOP MP3 Files (STOP Track)
  // ------------------------------------------------------------
  if (pmp3f == 4)
  {
    MP3player.stopTrack();             //Stop Track
    pmp3f = 0;
    return;
  }
}

// ------------------------------------------------------------------------------
// Check Alarm Time on RTC
// ------------------------------------------------------------------------------
int CheckAlarmTime()
{
  SPI.setBitOrder(MSBFIRST);
  SPI.setDataMode(SPI_MODE3);   //mode 3 works
  digitalWrite(rtc_cs, LOW);    //read RTC.
  SPI.transfer(0x0F);
  unsigned int n = SPI.transfer(0x0F);
  digitalWrite(rtc_cs, HIGH);
  WAKE_UP_JACK = SPI.transfer(0x0F) & B00000001; //A1F=1?
  delay(10);
  return (WAKE_UP_JACK);
}

// ------------------------------------------------------------------------------
// Clear Alarm Bit on RTC
// ------------------------------------------------------------------------------
void SilenceAlarm()
{
  SPI.setBitOrder(MSBFIRST);
  SPI.setDataMode(SPI_MODE3);  //mode 3 works
  //clear previous alarm
  digitalWrite(rtc_cs, LOW);
  SPI.transfer(0x0F);          //read reg 0F (control/status RTC reg)
  unsigned int n = SPI.transfer(0x0F);
  digitalWrite(rtc_cs, HIGH);
  delay(10);
  digitalWrite(rtc_cs, LOW);
  SPI.transfer(0x8F);          //clear only A1F bit. (Alarm Flag bit)
  SPI.transfer(n & B11111100);
  digitalWrite(rtc_cs, HIGH);
  delay(10);
}

// ------------------------------------------------------------------------------
// Read data from RTC SRAM.
// ------------------------------------------------------------------------------
void Read_RTC_SRAM()         // Get stored values.
{
  SPI.setBitOrder(MSBFIRST);
  SPI.setDataMode(SPI_MODE3);
  // ------------------------------------------
  // Read Background
  // ------------------------------------------
  digitalWrite(rtc_cs, LOW);
  SPI.transfer(0x098);                    // write 5 address to address reg 98H
  SPI.transfer(5);
  digitalWrite(rtc_cs, HIGH);
  delay(10);

  digitalWrite(rtc_cs, LOW);
  SPI.transfer(0x19);
  background = SPI.transfer(0x05);          // Get Background
  digitalWrite(rtc_cs, HIGH);
  delay(10);
  if (background < 1 || background > 4) {background = 1;}
  
  // ------------------------------------------
  // Read Wake Up Screen
  // ------------------------------------------
  digitalWrite(rtc_cs, LOW);
  SPI.transfer(0x098);                    // write 5 address to address reg 98H
  SPI.transfer(6);
  digitalWrite(rtc_cs, HIGH);
  delay(10);

  digitalWrite(rtc_cs, LOW);
  SPI.transfer(0x19);
  wakeupscreen = SPI.transfer(0x06);          // Get Wake Up Screen
  digitalWrite(rtc_cs, HIGH);
  delay(10);
  if (wakeupscreen < 1 || wakeupscreen > 3) {wakeupscreen = 1;}
  
  // ------------------------------------------
  // Read Announce Hourly
  // ------------------------------------------
  digitalWrite(rtc_cs, LOW);
  SPI.transfer(0x098);                    // write 5 address to address reg 98H
  SPI.transfer(7);
  digitalWrite(rtc_cs, HIGH);
  delay(10);

  digitalWrite(rtc_cs, LOW);
  SPI.transfer(0x19);
  announce_hourly = SPI.transfer(0x07);   // Get Announce Hourly
  digitalWrite(rtc_cs, HIGH);
  delay(10);
  if (announce_hourly > 1) {announce_hourly = 0;}
  
...

This file has been truncated, please download it to see its full contents.