///----------------------------------------------------------------------------
/// Function Break
///----------------------------------------------------------------------------
void PowerOffTimerCallback(void)
{
debug("Power Off Timer callback: activated.\r\n");
// Handle and finish any processing
StopMonitoring(g_triggerRecord.opMode, FINISH_PROCESSING);
if (g_timerModeLastRun == YES)
{
debug("Timer Mode: Ending last session, now disabling...\r\n");
g_unitConfig.timerMode = DISABLED;
// Save Unit Config (also covers LCD contrast change case)
SaveRecordData(&g_unitConfig, DEFAULT_RECORD, REC_UNIT_CONFIG_TYPE);
}
else if (g_lcdContrastChanged == YES)
{
// Save Unit Config here to prevent constant saving on LCD contrast adjustment
SaveRecordData(&g_unitConfig, DEFAULT_RECORD, REC_UNIT_CONFIG_TYPE);
}
OverlayMessage(getLangText(TIMER_MODE_TEXT), getLangText(POWERING_UNIT_OFF_NOW_TEXT), 3 * SOFT_SECS);
// Power the unit off
debug("Timer mode: Finished for the day, sleep time.\r\n");
PowerUnitOff(SHUTDOWN_UNIT);
}
///----------------------------------------------------------------------------
/// Function Break
///----------------------------------------------------------------------------
void LoadUnitConfig(void)
{
GetRecordData(&g_unitConfig, DEFAULT_RECORD, REC_UNIT_CONFIG_TYPE);
// Check if the Unit Config is uninitialized
if (g_unitConfig.validationKey != 0xA5A5)
{
// Set defaults in Unit Config
debugWarn("Unit Config: Not found.\r\n");
#if EXTENDED_DEBUG
debug("Loading Unit Config Defaults\r\n");
#endif
LoadUnitConfigDefaults((UNIT_CONFIG_STRUCT*)&g_unitConfig);
SaveRecordData(&g_unitConfig, DEFAULT_RECORD, REC_UNIT_CONFIG_TYPE);
}
else
{
// Unit Config is valid
#if EXTENDED_DEBUG
debug("Unit Config record is valid\r\n");
#endif
if ((g_unitConfig.pretrigBufferDivider != PRETRIGGER_BUFFER_QUARTER_SEC_DIV) && (g_unitConfig.pretrigBufferDivider != PRETRIGGER_BUFFER_HALF_SEC_DIV) &&
(g_unitConfig.pretrigBufferDivider != PRETRIGGER_BUFFER_FULL_SEC_DIV))
{
g_unitConfig.pretrigBufferDivider = PRETRIGGER_BUFFER_QUARTER_SEC_DIV;
SaveRecordData(&g_unitConfig, DEFAULT_RECORD, REC_UNIT_CONFIG_TYPE);
}
#if 1 // Forcing flash wrapping to be disabled
g_unitConfig.flashWrapping = NO;
#endif
#if 0 // Moved this init to the hardware section to allow for the saved Baud rate to be established from the start
// Set the baud rate to the user stored baud rate setting (initialized to 115200)
switch (g_unitConfig.baudRate)
{
case BAUD_RATE_57600: rs232Options.baudrate = 57600; break;
case BAUD_RATE_38400: rs232Options.baudrate = 38400; break;
case BAUD_RATE_19200: rs232Options.baudrate = 19200; break;
case BAUD_RATE_9600: rs232Options.baudrate = 9600; break;
}
if (g_unitConfig.baudRate != BAUD_RATE_115200)
{
// Re-Initialize the RS232 with the stored baud rate
usart_init_rs232(&AVR32_USART1, &rs232Options, FOSC0);
}
#endif
}
}
///----------------------------------------------------------------------------
/// Function Break
///----------------------------------------------------------------------------
void TimerModeActiveMinutes(void)
{
// Find the Time mode active time period in minutes
// Check for specialty case hourly
if (g_unitConfig.timerModeFrequency == TIMER_MODE_HOURLY)
{
// Check if the stop min is greater than the start min
if (g_unitConfig.timerStopTime.min > g_unitConfig.timerStartTime.min)
{
g_unitConfig.TimerModeActiveMinutes = (g_unitConfig.timerStopTime.min - g_unitConfig.timerStartTime.min);
}
else // The timer mode hourly active period will cross the hour boundary
{
g_unitConfig.TimerModeActiveMinutes = (60 + g_unitConfig.timerStopTime.min - g_unitConfig.timerStartTime.min);
}
// In order to restart up every hour, the active minutes needs to be less than 60, 1 min for shutdown + 1 min for being off
if (g_unitConfig.TimerModeActiveMinutes > 58)
g_unitConfig.TimerModeActiveMinutes = 58;
}
// Check if the stop time (in minutes resolution) is greater than the start time, thus running the same day
else if (((g_unitConfig.timerStopTime.hour * 60) + g_unitConfig.timerStopTime.min) >
((g_unitConfig.timerStartTime.hour * 60) + g_unitConfig.timerStartTime.min))
{
// Set active minutes as the difference in the stop and start times
g_unitConfig.TimerModeActiveMinutes = (uint16)(((g_unitConfig.timerStopTime.hour * 60) + g_unitConfig.timerStopTime.min) -
((g_unitConfig.timerStartTime.hour * 60) + g_unitConfig.timerStartTime.min));
// Check for specialty case one time
if (g_unitConfig.timerModeFrequency == TIMER_MODE_ONE_TIME)
{
// Calculate the number of days to run consecutively (Days * Hours in a day * Minutes in an hour) and add to the active minutes
g_unitConfig.TimerModeActiveMinutes += (24 * 60 * (GetTotalDaysFromReference(g_unitConfig.timerStopDate) -
GetTotalDaysFromReference(g_unitConfig.timerStartDate)));
}
}
else // The timer mode active period will see midnight, thus running 2 consecutive days
{
// Set active minutes as the difference from midnight and the start time, plus the stop time the next day
g_unitConfig.TimerModeActiveMinutes = (uint16)((24 * 60) - ((g_unitConfig.timerStartTime.hour * 60) + g_unitConfig.timerStartTime.min) +
((g_unitConfig.timerStopTime.hour * 60) + g_unitConfig.timerStopTime.min));
// Check for specialty case one time
if (g_unitConfig.timerModeFrequency == TIMER_MODE_ONE_TIME)
{
// Calculate the number of days to run consecutively (Days * Hours in a day * Minutes in an hour) minus crossover day and add to the active minutes
g_unitConfig.TimerModeActiveMinutes += (24 * 60 * (GetTotalDaysFromReference(g_unitConfig.timerStopDate) -
GetTotalDaysFromReference(g_unitConfig.timerStartDate) - 1));
}
}
debug("Timer Active Minutes: %d\r\n", g_unitConfig.TimerModeActiveMinutes);
SaveRecordData(&g_unitConfig, DEFAULT_RECORD, REC_UNIT_CONFIG_TYPE);
}
///----------------------------------------------------------------------------
/// Function Break
///----------------------------------------------------------------------------
void LoadDefaultTriggerRecord(void)
{
GetRecordData(&g_triggerRecord, DEFAULT_RECORD, REC_TRIGGER_USER_MENU_TYPE);
// Check if the Default Trig Record is uninitialized
if (g_triggerRecord.validRecord != YES)
{
debugWarn("Default Trigger Record: Invalid, loading defaults\r\n");
LoadTrigRecordDefaults(&g_triggerRecord, WAVEFORM_MODE);
SaveRecordData(&g_triggerRecord, DEFAULT_RECORD, REC_TRIGGER_USER_MENU_TYPE);
}
else
{
debug("Default Trigger record is valid\r\n");
}
}
///----------------------------------------------------------------------------
/// Function Break
///----------------------------------------------------------------------------
void HandleUserPowerOffDuringTimerMode(void)
{
INPUT_MSG_STRUCT mn_msg;
uint8 choice;
// Simulate a keypress if the user pressed the off key, which doesn't register as a keypess
KeypressEventMgr();
MessageBox(getLangText(STATUS_TEXT), getLangText(UNIT_IS_IN_TIMER_MODE_TEXT), MB_OK);
choice = MessageBox(getLangText(WARNING_TEXT), getLangText(CANCEL_TIMER_MODE_Q_TEXT), MB_YESNO);
// User decided to cancel Timer mode
if (choice == MB_FIRST_CHOICE)
{
g_unitConfig.timerMode = DISABLED;
// Disable the Power Off timer
ClearSoftTimer(POWER_OFF_TIMER_NUM);
// Save Unit Config
SaveRecordData(&g_unitConfig, DEFAULT_RECORD, REC_UNIT_CONFIG_TYPE);
OverlayMessage(getLangText(STATUS_TEXT), getLangText(TIMER_MODE_DISABLED_TEXT), 2 * SOFT_SECS);
}
else // User decided to stay in Timer mode
{
choice = MessageBox(getLangText(STATUS_TEXT), getLangText(POWER_UNIT_OFF_EARLY_Q_TEXT), MB_YESNO);
if (choice == MB_FIRST_CHOICE)
{
MessageBox(getLangText(STATUS_TEXT), getLangText(POWERING_UNIT_OFF_NOW_TEXT), MB_OK);
MessageBox(getLangText(STATUS_TEXT), getLangText(PLEASE_PRESS_ENTER_TEXT), MB_OK);
// Turn unit off/sleep
debug("Timer mode: Shutting down unit early due to user request. Powering off now...\r\n");
PowerUnitOff(SHUTDOWN_UNIT); // Return unnecessary
}
}
SETUP_MENU_MSG(MAIN_MENU);
JUMP_TO_ACTIVE_MENU();
}
///----------------------------------------------------------------------------
/// Function Break
///----------------------------------------------------------------------------
void LoadModemSetupRecord(void)
{
GetRecordData(&g_modemSetupRecord, 0, REC_MODEM_SETUP_TYPE);
// Check if the Modem Setup Record is invalid
if (g_modemSetupRecord.invalid)
{
// Warn the user
debugWarn("Modem setup record not found.\r\n");
// Initialize the Modem Setup Record
LoadModemSetupRecordDefaults();
// Save the Modem Setup Record
SaveRecordData(&g_modemSetupRecord, DEFAULT_RECORD, REC_MODEM_SETUP_TYPE);
}
else
{
#if EXTENDED_DEBUG
debug("Modem Setup record is valid\r\n");
#endif
ValidateModemSetupParameters();
}
}
///----------------------------------------------------------------------------
/// Function Break
///----------------------------------------------------------------------------
void ProcessTimerModeSettings(uint8 mode)
{
//uint8 dayOfWeek = 0;
uint8 startDay = 0;
uint8 startHour = 0;
uint16 minutesLeft = 0;
DATE_TIME_STRUCT currentTime = GetCurrentTime();
uint8 status = ValidateTimerModeSettings();
// Check if the timer mode settings check failed or if the timer mode setting has been disabled
if ((status == FAILED) || (g_unitConfig.timerMode == DISABLED))
{
g_unitConfig.timerMode = DISABLED;
SaveRecordData(&g_unitConfig, DEFAULT_RECORD, REC_UNIT_CONFIG_TYPE);
// Disable the Power Off timer in case it's set
ClearSoftTimer(POWER_OFF_TIMER_NUM);
if (mode == PROMPT)
{
sprintf((char*)g_spareBuffer, "%s %s", getLangText(TIMER_SETTINGS_INVALID_TEXT), getLangText(TIMER_MODE_DISABLED_TEXT));
MessageBox(getLangText(ERROR_TEXT), (char*)g_spareBuffer, MB_OK);
}
}
else // status == PASSED || status == IN_PROGRESS
{
// Calculate timer mode active run time in minutes
TimerModeActiveMinutes();
// Init start day based on the start date provided by the user
startDay = g_unitConfig.timerStartDate.day;
// Check if in progress, requiring extra logic to determine alarm settings
if (status == IN_PROGRESS)
{
// Check if the stop time is greater than the start time
if ((g_unitConfig.timerStopTime.hour > g_unitConfig.timerStartTime.hour) ||
((g_unitConfig.timerStopTime.hour == g_unitConfig.timerStartTime.hour) &&
(g_unitConfig.timerStopTime.min > g_unitConfig.timerStartTime.min)))
{
// Advance the start day
startDay++;
// Check if the start day is beyond the total days in the current month
if (startDay > g_monthTable[(uint8)(g_unitConfig.timerStartDate.month)].days)
{
// Set the start day to the first day of next month
startDay = 1;
}
}
}
// Check for specialty case hourly mode and in progress, requiring extra logic to determine alarm settings
if ((g_unitConfig.timerModeFrequency == TIMER_MODE_HOURLY) && (status == IN_PROGRESS))
{
// Check if another hour time slot to run again today
if (currentTime.hour != g_unitConfig.timerStopTime.hour)
{
// Start day remains the same
startDay = g_unitConfig.timerStartDate.day;
// Check if current hour time slot has not started
if (currentTime.min < g_unitConfig.timerStartTime.min)
{
// Set alarm for the same hour
startHour = currentTime.hour;
}
else
{
// Set alarm for the next hour
startHour = currentTime.hour + 1;
// Account for end of day boundary
if (startHour > 23)
{
startHour = 0;
// Advance the start day
startDay++;
// Check if the start day is beyond the total days in the current month
if (startDay > g_monthTable[(uint8)(g_unitConfig.timerStartDate.month)].days)
{
// Set the start day to the first day of next month
startDay = 1;
}
}
}
EnableExternalRtcAlarm(startDay, startHour, g_unitConfig.timerStartTime.min, 0);
}
else // This is the last hour time slot to run today, set alarm for next day
{
// startDay calculated correctly in above previous status == IN_PROGRESS logic
EnableExternalRtcAlarm(startDay, g_unitConfig.timerStartTime.hour, g_unitConfig.timerStartTime.min, 0);
}
}
else // All other timer modes
{
EnableExternalRtcAlarm(startDay, g_unitConfig.timerStartTime.hour, g_unitConfig.timerStartTime.min, 0);
}
if (status == PASSED)
{
if (mode == PROMPT)
{
sprintf((char*)g_spareBuffer, "%s %s", getLangText(TIMER_MODE_NOW_ACTIVE_TEXT), getLangText(PLEASE_POWER_OFF_UNIT_TEXT));
MessageBox(getLangText(STATUS_TEXT), (char*)g_spareBuffer, MB_OK);
}
// Check if start time is greater than the current time
if (((g_unitConfig.timerStartTime.hour * 60) + g_unitConfig.timerStartTime.min) >
((currentTime.hour * 60) + currentTime.min))
{
// Take the difference between start time and current time
minutesLeft = (uint16)(((g_unitConfig.timerStartTime.hour * 60) + g_unitConfig.timerStartTime.min) -
((currentTime.hour * 60) + currentTime.min));
}
else // Current time is after the start time, meaning the start time is the next day
{
// Take the difference between 24 hours and the current time plus the start time
minutesLeft = (uint16)((24 * 60) - ((currentTime.hour * 60) + currentTime.min) +
((g_unitConfig.timerStartTime.hour * 60) + g_unitConfig.timerStartTime.min));
}
// Check if the start time is within the next minute
if (minutesLeft <= 1)
{
OverlayMessage(getLangText(WARNING_TEXT), getLangText(POWERING_UNIT_OFF_NOW_TEXT), 2 * SOFT_SECS);
// Need to shutdown the unit now, otherwise the start time window will be missed
PowerUnitOff(SHUTDOWN_UNIT); // Return unnecessary
}
else // More than 1 minute left before the start time
{
// Make sure the unit turns off one minute before the start time if the user forgets to turn the unit off
minutesLeft -= 1;
// Need to handle state where timer mode is going active but unit hasn't power cycled into timer mode yet
g_allowQuickPowerOffForTimerModeSetup = YES;
// Set the Power off soft timer to prevent the unit from staying on past the Timer mode start time
AssignSoftTimer(POWER_OFF_TIMER_NUM, (uint32)(minutesLeft * 60 * 2), PowerOffTimerCallback);
}
}
else // status == IN_PROGRESS
{
if (mode == PROMPT)
{
sprintf((char*)g_spareBuffer, "%s", getLangText(TIMER_MODE_NOW_ACTIVE_TEXT));
MessageBox(getLangText(STATUS_TEXT), (char*)g_spareBuffer, MB_OK);
}
// Check if specialty mode hourly
if (g_unitConfig.timerModeFrequency == TIMER_MODE_HOURLY)
{
if (currentTime.min < g_unitConfig.timerStopTime.min)
{
minutesLeft = (g_unitConfig.timerStopTime.min - currentTime.min);
}
else
{
minutesLeft = (60 + g_unitConfig.timerStopTime.min - currentTime.min);
}
if (minutesLeft > 58)
minutesLeft = 58;
}
// Check if the current time is greater than the stop time, indicating that midnight boundary was crossed
else if (((currentTime.hour * 60) + currentTime.min) > ((g_unitConfig.timerStopTime.hour * 60) + g_unitConfig.timerStopTime.min))
{
// Calculate the time left before powering off to be 24 + the stop time minus the current time
minutesLeft = (uint16)(((24 * 60) + (g_unitConfig.timerStopTime.hour * 60) + g_unitConfig.timerStopTime.min) -
((currentTime.hour * 60) + currentTime.min));
}
else // Current time is less than start time, operating within the same day
{
// Calculate the time left before powering off to be the stop time minus the current time
minutesLeft = (uint16)(((g_unitConfig.timerStopTime.hour * 60) + g_unitConfig.timerStopTime.min) -
((currentTime.hour * 60) + currentTime.min));
}
// Make sure timeout value is not zero
if (minutesLeft == 0) minutesLeft = 1;
debug("Timer Mode: In progress, minutes left before power off: %d (Expired secs this min: %d)\r\n", minutesLeft, currentTime.sec);
// Setup soft timer to turn system off when timer mode is finished for the day
AssignSoftTimer(POWER_OFF_TIMER_NUM, (uint32)((minutesLeft * 60 * 2) - (currentTime.sec * 2)), PowerOffTimerCallback);
}
}
}
///----------------------------------------------------------------------------
/// Function Break
///----------------------------------------------------------------------------
BOOLEAN TimerModeActiveCheck(void)
{
BOOLEAN status = FALSE;
DATE_TIME_STRUCT time = GetExternalRtcTime();
uint8 choice;
if (g_unitConfig.validationKey == 0xA5A5)
{
// Check if timer mode is enabled
if (g_unitConfig.timerMode == ENABLED)
{
debug("Timer Mode active\r\n");
// Check if the timer mode settings match the current hour and minute meaning the unit powered itself on
if ((g_unitConfig.timerStartTime.hour == time.hour) && (g_unitConfig.timerStartTime.min == time.min))
{
debug("Timer Mode Check: Matched Timer settings...\r\n");
status = TRUE;
}
// Check again if settings match current hour and near minute meaning unit powered itself on but suffered from long startup
else if ((g_unitConfig.timerStartTime.hour == time.hour) &&
((((g_unitConfig.timerStartTime.min + 1) == 60) && (time.min == 0)) || ((g_unitConfig.timerStartTime.min + 1) == time.min)))
{
debug("Timer Mode Check: Matched Timer settings (long startup)...\r\n");
status = TRUE;
}
// Check specialty hourly mode and if current minute matches and the current hour is within range
else if ((g_unitConfig.timerModeFrequency == TIMER_MODE_HOURLY) && (g_unitConfig.timerStartTime.min == time.min) &&
// Check if the start and stop hours match meaning hourly mode runs every hour
((g_unitConfig.timerStartTime.hour == g_unitConfig.timerStopTime.hour) ||
// OR Check if hourly mode does not cross a 24 hour boundary and the current hour is within range
((g_unitConfig.timerStartTime.hour < g_unitConfig.timerStopTime.hour) && (time.hour >= g_unitConfig.timerStartTime.hour) &&
(time.hour <= g_unitConfig.timerStopTime.hour)) ||
// OR Check if the current hour is within range with an hourly mode that does cross a 24 hour boundary
((time.hour >= g_unitConfig.timerStartTime.hour) || (time.hour <= g_unitConfig.timerStopTime.hour))))
{
debug("Timer Mode Check: Matched Timer settings (hourly)...\r\n");
status = TRUE;
}
else
{
MessageBox(getLangText(STATUS_TEXT), getLangText(UNIT_IS_IN_TIMER_MODE_TEXT), MB_OK);
choice = MessageBox(getLangText(WARNING_TEXT), getLangText(CANCEL_TIMER_MODE_Q_TEXT), MB_YESNO);
if (choice == MB_FIRST_CHOICE)
{
g_unitConfig.timerMode = DISABLED;
// Save Unit Config
SaveRecordData(&g_unitConfig, DEFAULT_RECORD, REC_UNIT_CONFIG_TYPE);
OverlayMessage(getLangText(STATUS_TEXT), getLangText(TIMER_MODE_DISABLED_TEXT), 2 * SOFT_SECS);
}
else // User decided to stay in Timer mode
{
// TOD Alarm registers still set from previous run, TOD Alarm Mask re-enabled in rtc init
// Clear TOD Alarm Mask to allow TOD Alarm interrupt to be generated
// ADD CODE TO CLEAR ALARM
OverlayMessage(getLangText(WARNING_TEXT), getLangText(POWERING_UNIT_OFF_NOW_TEXT), 2 * SOFT_SECS);
// Turn unit off/sleep
debug("Timer mode: Staying in Timer mode. Powering off now...\r\n");
PowerUnitOff(SHUTDOWN_UNIT); // Return unnecessary
}
}
}
}
return (status);
}
///----------------------------------------------------------------------------
/// Function Break
///----------------------------------------------------------------------------
void ResetTimeOfDayAlarm(void)
{
DATE_TIME_STRUCT currTime = GetExternalRtcTime();
uint8 startDay = 0;
uint8 startHour = 0;
uint8 month;
// RTC Weekday's: Sunday = 1, Monday = 2, Tuesday = 3, Wednesday = 4, Thursday = 5, Friday = 6, Saturday = 7
//___________________________________________________________________________________________
//___TIMER_MODE_DAILY
if (g_unitConfig.timerModeFrequency == TIMER_MODE_DAILY)
{
#if 1 // Normal
// Get the current day and add one
startDay = (currTime.day + 1);
// Check if the start day is beyond the total days in the current month
if (startDay > g_monthTable[currTime.month].days)
{
// Set the start day to the first of next month
startDay = 1;
}
debug("Timer mode: Resetting TOD Alarm with (hour) %d, (min) %d, (start day) %d\r\n",
g_unitConfig.timerStartTime.hour, g_unitConfig.timerStartTime.min, startDay);
#else // Test
// Loop test on and off in a cycle
startDay = currTime.day;
g_unitConfig.timerStartTime.min += 3;
if (g_unitConfig.timerStartTime.min >= 60)
{
g_unitConfig.timerStartTime.min -= 60;
g_unitConfig.timerStartTime.hour += 1;
if (g_unitConfig.timerStartTime.hour >= 24)
{
g_unitConfig.timerStartTime.hour = 0;
startDay = currTime.day + 1; // Ignore month boundary for testing
}
}
// Save new testing timer mode adjustments
SaveRecordData(&g_unitConfig, DEFAULT_RECORD, REC_UNIT_CONFIG_TYPE);
debug("Timer mode: Resetting TOD Alarm with (hour) %d, (min) %d, (start day) %d\r\n",
g_unitConfig.timerStartTime.hour, g_unitConfig.timerStartTime.min, startDay);
#endif
EnableExternalRtcAlarm(startDay, g_unitConfig.timerStartTime.hour, g_unitConfig.timerStartTime.min, 0);
}
//___________________________________________________________________________________________
//___TIMER_MODE_HOURLY
else if (g_unitConfig.timerModeFrequency == TIMER_MODE_HOURLY)
{
// Establish most common value for the start day
startDay = currTime.day;
// Check if another hour time slot to run again today
if (currTime.hour != g_unitConfig.timerStopTime.hour)
{
// Set alarm for the next hour
startHour = currTime.hour + 1;
// Account for end of day boundary
if (startHour > 23)
{
startHour = 0;
// Get the current day and add one
startDay = (currTime.day + 1);
// Check if the start day is beyond the total days in the current month
if (startDay > g_monthTable[currTime.month].days)
{
// Set the start day to the first of next month
startDay = 1;
}
}
}
else // Last hour time slot to run today, set alarm for next hour grouping
{
// Establish the most common value for the start hour
startHour = g_unitConfig.timerStartTime.hour;
// Check if the setup time did not cross the midnight boundary
if (g_unitConfig.timerStartTime.hour < g_unitConfig.timerStopTime.hour)
{
// Set to the following day
startDay++;
// Check if the start day is beyond the total days in the current month
if (startDay > g_monthTable[currTime.month].days)
{
// Set the start day to the first of next month
startDay = 1;
}
}
// Check if start and stop hour are the same meaning hourly mode runs every hour of every day
else if (g_unitConfig.timerStartTime.hour == g_unitConfig.timerStopTime.hour)
{
// Current hour matches start and stop, need to set start hour to the following hour slot
startHour = (currTime.hour + 1);
// Check if start hour is into tomorrow
if (startHour > 23)
{
// Set start hour to the first hour
startHour = 0;
// Set to the following day
startDay++;
// Check if the start day is beyond the total days in the current month
if (startDay > g_monthTable[currTime.month].days)
{
// Set the start day to the first of next month
startDay = 1;
}
}
}
// else the startDay remains today (start day is today, start hour is timer mode start hour)
}
debug("Timer mode: Resetting TOD Alarm with (hour) %d, (min) %d, (start day) %d\r\n",
startHour, g_unitConfig.timerStartTime.min, startDay);
EnableExternalRtcAlarm(startDay, startHour, g_unitConfig.timerStartTime.min, 0);
}
//___________________________________________________________________________________________
//___TIMER_MODE_WEEKDAYS
else if (g_unitConfig.timerModeFrequency == TIMER_MODE_WEEKDAYS)
{
// Get the current day
startDay = currTime.day;
if (currTime.weekday == FRI)
{
// Advance 3 days
startDay += 3;
}
else if (currTime.weekday == SAT)
{
// Advance 2 days
startDay += 2;
}
else // The rest of the days of the week
{
// Advance 1 day
startDay++;
}
// Check if the start day is beyond the number of days in the current month
if (startDay > g_monthTable[currTime.month].days)
{
// Subtract out the number of days in the current month to get the start day for next month
startDay -= g_monthTable[currTime.month].days;
}
debug("Timer mode: Resetting TOD Alarm with (hour) %d, (min) %d, (start ay) %d\r\n",
g_unitConfig.timerStartTime.hour, g_unitConfig.timerStartTime.min, startDay);
EnableExternalRtcAlarm(startDay, g_unitConfig.timerStartTime.hour, g_unitConfig.timerStartTime.min, 0);
}
//___________________________________________________________________________________________
//___TIMER_MODE_WEEKLY
else if (g_unitConfig.timerModeFrequency == TIMER_MODE_WEEKLY)
{
// Set the start day to the current day + 7 days
startDay = (uint8)(currTime.day + 7);
// Check if the start day is beyond the number of days in the current month
if (startDay > g_monthTable[currTime.month].days)
{
// Subtract out the days of the current month to get the start day for next month
startDay -= g_monthTable[currTime.month].days;
}
debug("Timer mode: Resetting TOD Alarm with (hour) %d, (min) %d, (start day) %d\r\n",
g_unitConfig.timerStartTime.hour, g_unitConfig.timerStartTime.min, startDay);
EnableExternalRtcAlarm(startDay, g_unitConfig.timerStartTime.hour, g_unitConfig.timerStartTime.min, 0);
}
//___________________________________________________________________________________________
//___TIMER_MODE_MONTHLY
else if (g_unitConfig.timerModeFrequency == TIMER_MODE_MONTHLY)
{
// Check if advancing a month is still within the same year
if (currTime.month + 1 <= 12)
{
month = (uint8)(currTime.month + 1);
}
else // It's December and next month is Jan
{
month = 1;
}
// Get the current day
startDay = currTime.day;
// Check if the stat day is greater than the total number of days in the next month
if (startDay > g_monthTable[month].days)
{
// Limit the start day to the last day of the next month
startDay = (uint8)(g_monthTable[month].days);
}
debug("Timer mode: Resetting TOD Alarm with (hour) %d, (min) %d, (start day) %d\r\n",
g_unitConfig.timerStartTime.hour, g_unitConfig.timerStartTime.min, startDay);
EnableExternalRtcAlarm(startDay, g_unitConfig.timerStartTime.hour, g_unitConfig.timerStartTime.min, 0);
}
}
///----------------------------------------------------------------------------
/// Function Break
///----------------------------------------------------------------------------
void ProcessTimerMode(void)
{
DATE_TIME_STRUCT currTime = GetExternalRtcTime();
// Check if the Timer mode activated after stop date
if (// First Check for past year
(currTime.year > g_unitConfig.timerStopDate.year) ||
// Second check for equal year but past month
((currTime.year == g_unitConfig.timerStopDate.year) && (currTime.month > g_unitConfig.timerStopDate.month)) ||
// Third check for equal year, equal month, but past day
((currTime.year == g_unitConfig.timerStopDate.year) && (currTime.month == g_unitConfig.timerStopDate.month) &&
(currTime.day > g_unitConfig.timerStopDate.day)))
{
// Disable alarm output generation
debug("Timer Mode: Activated after date...\r\n");
debug("Timer Mode: Disabling...\r\n");
g_unitConfig.timerMode = DISABLED;
// Save Unit Config
SaveRecordData(&g_unitConfig, DEFAULT_RECORD, REC_UNIT_CONFIG_TYPE);
// Deactivate alarm interrupts
DisableExternalRtcAlarm();
// Turn unit off/sleep
debug("Timer mode: Powering unit off...\r\n");
PowerUnitOff(SHUTDOWN_UNIT); // Return unnecessary
}
// Check if the Timer mode activated before start date
else if (// First Check for before year
(currTime.year < g_unitConfig.timerStartDate.year) ||
// Second check for equal year but before month
((currTime.year == g_unitConfig.timerStartDate.year) && (currTime.month < g_unitConfig.timerStartDate.month)) ||
// Third check for equal year, equal month, but before day
((currTime.year == g_unitConfig.timerStartDate.year) && (currTime.month == g_unitConfig.timerStartDate.month) &&
(currTime.day < g_unitConfig.timerStartDate.day)))
{
debug("Timer Mode: Activated before date...\r\n");
ResetTimeOfDayAlarm();
// Turn unit off/sleep
debug("Timer mode: Powering unit off...\r\n");
PowerUnitOff(SHUTDOWN_UNIT); // Return unnecessary
}
// Check if the Timer mode activated during active dates but on an off day
else if ((g_unitConfig.timerModeFrequency == TIMER_MODE_WEEKDAYS) && ((currTime.weekday == SAT) || (currTime.weekday == SUN)))
{
debug("Timer Mode: Activated on an off day (weekday freq)...\r\n");
ResetTimeOfDayAlarm();
// Turn unit off/sleep
debug("Timer mode: Powering unit off...\r\n");
PowerUnitOff(SHUTDOWN_UNIT); // Return unnecessary
}
// Check if the Timer mode activated during active dates but on an off day
else if ((g_unitConfig.timerModeFrequency == TIMER_MODE_MONTHLY) && (currTime.day != g_unitConfig.timerStartDate.day))
{
debug("Timer Mode: Activated on off day (monthly freq)...\r\n");
ResetTimeOfDayAlarm();
// Turn unit off/sleep
debug("Timer mode: Powering unit off...\r\n");
PowerUnitOff(SHUTDOWN_UNIT); // Return unnecessary
}
// Check if the Timer mode activated on end date (and not hourly mode)
else if ((g_unitConfig.timerModeFrequency != TIMER_MODE_HOURLY) && (currTime.year == g_unitConfig.timerStopDate.year) &&
(currTime.month == g_unitConfig.timerStopDate.month) && (currTime.day == g_unitConfig.timerStopDate.day))
{
// Disable alarm output generation
debug("Timer Mode: Activated on end date...\r\n");
// Signal the timer mode end of session timer to stop timer mode due to this being the last run
g_timerModeLastRun = YES;
// Deactivate alarm interrupts
DisableExternalRtcAlarm();
}
// Check if the Timer mode activated on end date and end hour (hourly mode)
else if ((g_unitConfig.timerModeFrequency == TIMER_MODE_HOURLY) && (currTime.year == g_unitConfig.timerStopDate.year) &&
(currTime.month == g_unitConfig.timerStopDate.month) && (currTime.day == g_unitConfig.timerStopDate.day) &&
(currTime.hour == g_unitConfig.timerStopTime.hour))
{
// Disable alarm output generation
debug("Timer Mode: Activated on end date...\r\n");
// Signal the timer mode end of session timer to stop timer mode due to this being the last run
g_timerModeLastRun = YES;
// Deactivate alarm interrupts
DisableExternalRtcAlarm();
}
else // Timer mode started during the active dates on a day it's supposed to run
{
if (g_unitConfig.timerModeFrequency == TIMER_MODE_ONE_TIME)
{
// Signal the timer mode end of session timer to stop timer mode due to this being the last run
g_timerModeLastRun = YES;
// Deactivate alarm interrupts
DisableExternalRtcAlarm();
}
else // All other timer modes
{
// Reset the Time of Day Alarm to wake the unit up again
ResetTimeOfDayAlarm();
}
}
OverlayMessage(getLangText(STATUS_TEXT), getLangText(TIMER_MODE_NOW_ACTIVE_TEXT), (2 * SOFT_SECS));
raiseTimerEventFlag(TIMER_MODE_TIMER_EVENT);
// Setup soft timer to turn system off when timer mode is finished for the day (minus the expired secs in the current minute
AssignSoftTimer(POWER_OFF_TIMER_NUM, ((g_unitConfig.TimerModeActiveMinutes * 60 * 2) - (currTime.sec * 2)), PowerOffTimerCallback);
debug("Timer mode: running...\r\n");
}
///----------------------------------------------------------------------------
/// Function Break
///----------------------------------------------------------------------------
void LoadRecordMenuProc(INPUT_MSG_STRUCT msg, WND_LAYOUT_STRUCT *wnd_layout_ptr, MN_LAYOUT_STRUCT *mn_layout_ptr)
{
uint8 buff[20];
REC_EVENT_MN_STRUCT temp_rec;
INPUT_MSG_STRUCT mn_msg;
uint32 input;
uint8 i;
switch (msg.cmd)
{
case (ACTIVATE_MENU_CMD):
wnd_layout_ptr->start_col = LOAD_REC_WND_STARTING_COL;
wnd_layout_ptr->end_col = LOAD_REC_WND_END_COL;
wnd_layout_ptr->start_row = LOAD_REC_WND_STARTING_ROW;
wnd_layout_ptr->end_row = LOAD_REC_WND_END_ROW;
mn_layout_ptr->curr_ln = 1;
mn_layout_ptr->top_ln = 1;
LoadTempMenuTable(s_loadRecordMenuTable);
for (i = 1; i <= MAX_NUM_OF_SAVED_SETUPS; i++)
{
GetRecordData(&temp_rec, i, REC_TRIGGER_USER_MENU_TYPE);
if (temp_rec.validRecord == YES)
{
switch (temp_rec.opMode)
{
case (WAVEFORM_MODE):
sprintf((char*)buff, "%s (%s)", (char*)temp_rec.name, getLangText(SELF_TRG_TEXT));
break;
case (BARGRAPH_MODE):
sprintf((char*)buff, "%s (%s)", (char*)temp_rec.name, getLangText(BAR_TEXT));
break;
case (COMBO_MODE):
sprintf((char*)buff, "%s (%s)", (char*)temp_rec.name, getLangText(COMBO_TEXT));
break;
default:
sprintf((char*)buff, "%s (UNK)", (char*)temp_rec.name);
break;
}
}
else
{
sprintf((char*)buff, "<%s>", getLangText(EMPTY_TEXT));
}
// Add 3 to i to offset past the default settings
strcpy((char*)&(g_menuPtr[i + 3].data[0]), (char*)buff);
}
// Add in the "<END>" text to signal the end of the list
sprintf((char*)buff, "<%s>", getLangText(END_TEXT));
strcpy((char*)&(g_menuPtr[i + 3].data[0]), (char*)buff);
i++;
// Add the end string to allow other routines to match on the end of the menu
strcpy((char*)&(g_menuPtr[i + 3].data[0]), ".end.");
break;
case (KEYPRESS_MENU_CMD):
input = msg.data[0];
switch (input)
{
case (ENTER_KEY):
switch (mn_layout_ptr->curr_ln)
{
case (1):
LoadTrigRecordDefaults(&g_triggerRecord, WAVEFORM_MODE);
break;
case (2):
LoadTrigRecordDefaults(&g_triggerRecord, BARGRAPH_MODE);
break;
case (3):
LoadTrigRecordDefaults(&g_triggerRecord, COMBO_MODE);
break;
default:
// Check if the first char matches a "<" for either "<EMPTY>" or "<END>"
if (strncmp((char*)&g_menuPtr[mn_layout_ptr->curr_ln].data[0], "<", 1) == 0)
{
// Record slot is empty, do nothing
return;
}
else
{
GetRecordData(&g_triggerRecord, (uint32)(mn_layout_ptr->curr_ln - 3), REC_TRIGGER_USER_MENU_TYPE);
}
break;
}
UpdateModeMenuTitle(g_triggerRecord.opMode);
SETUP_USER_MENU_MSG(&modeMenu, MONITOR);
JUMP_TO_ACTIVE_MENU();
break;
case (DELETE_KEY):
// Check if the current line is beyond the default entries
if (mn_layout_ptr->curr_ln > 3)
{
GetRecordData(&temp_rec, (uint32)(mn_layout_ptr->curr_ln - 3), REC_TRIGGER_USER_MENU_TYPE);
if (temp_rec.validRecord == YES)
{
sprintf((char*)g_spareBuffer, "%s (%s)", getLangText(DELETE_SAVED_SETUP_Q_TEXT), temp_rec.name);
if (MessageBox(getLangText(WARNING_TEXT), (char*)g_spareBuffer, MB_YESNO) == MB_FIRST_CHOICE)
{
memset(&temp_rec.name, 0, sizeof(temp_rec.name));
temp_rec.validRecord = NO;
SaveRecordData(&temp_rec, (uint32)(mn_layout_ptr->curr_ln - 3), REC_TRIGGER_USER_MENU_TYPE);
sprintf((char*)&(g_menuPtr[mn_layout_ptr->curr_ln].data[0]), "<%s>", getLangText(EMPTY_TEXT));
}
}
}
break;
case (DOWN_ARROW_KEY):
MenuScroll(DOWN, SELECT_MN_WND_LNS, mn_layout_ptr);
// Prevent the cursor from selecting the "<END>" text
if (mn_layout_ptr->curr_ln == 18)
{
mn_layout_ptr->curr_ln = 17;
}
break;
case (UP_ARROW_KEY):
MenuScroll(UP, SELECT_MN_WND_LNS, mn_layout_ptr);
break;
case (ESC_KEY):
SETUP_MENU_MSG(MAIN_MENU);
mn_msg.data[0] = ESC_KEY;
JUMP_TO_ACTIVE_MENU();
break;
case (HELP_KEY):
SETUP_USER_MENU_MSG(&helpMenu, CONFIG);
JUMP_TO_ACTIVE_MENU();
break;
default:
break;
}
break;
default:
break;
}
}
///----------------------------------------------------------------------------
/// Function Break
///----------------------------------------------------------------------------
void LoadFactorySetupRecord(void)
{
DATE_TIME_STRUCT tempTime;
char buff[50];
GetRecordData(&g_factorySetupRecord, DEFAULT_RECORD, REC_FACTORY_SETUP_TYPE);
// Check if the Factory Setup Record is invalid
if (g_factorySetupRecord.invalid)
{
// Warn the user
debugWarn("Factory setup record not found.\r\n");
OverlayMessage(getLangText(ERROR_TEXT), getLangText(FACTORY_SETUP_DATA_COULD_NOT_BE_FOUND_TEXT), (2 * SOFT_SECS));
// Check if the Shadow Factory setup is valid
if (!SHADOW_FACTORY_SETUP_CLEARED)
{
// Warn the user
debugWarn("Factory setup shadow copy exists.\r\n");
if (MessageBox(getLangText(CONFIRM_TEXT), getLangText(RESTORE_FACTORY_SETUP_FROM_BACKUP_Q_TEXT), MB_YESNO) == MB_FIRST_CHOICE)
{
GetFlashUserPageFactorySetup(&g_factorySetupRecord);
SaveRecordData(&g_factorySetupRecord, DEFAULT_RECORD, REC_FACTORY_SETUP_TYPE);
}
}
}
// Check if the Factory Setup Record is valid (in case shadow factory setup was copied over)
if (!g_factorySetupRecord.invalid)
{
if (g_seismicSmartSensorMemory.version & SMART_SENSOR_OVERLAY_KEY)
{
g_factorySetupRecord.seismicSensorType = (pow(2, g_seismicSmartSensorMemory.sensorType) * SENSOR_2_5_IN);
}
if (g_acousticSmartSensorMemory.version & SMART_SENSOR_OVERLAY_KEY)
{
if ((g_acousticSmartSensorMemory.sensorType == SENSOR_MIC_148) || (g_acousticSmartSensorMemory.sensorType == SENSOR_MIC_160))
{
g_factorySetupRecord.acousticSensorType = g_acousticSmartSensorMemory.sensorType;
}
}
UpdateWorkingCalibrationDate();
// Print the Factory Setup Record to the console
memset(&buff[0], 0, sizeof(buff));
ConvertCalDatetoDateTime(&tempTime, &g_currentCalibration.date);
ConvertTimeStampToString(buff, &tempTime, REC_DATE_TYPE);
if (g_factorySetupRecord.seismicSensorType > SENSOR_ACC_RANGE_DIVIDER) { strcpy((char*)&g_spareBuffer, "Acc"); }
else { sprintf((char*)&g_spareBuffer, "%3.1f in", (float)g_factorySetupRecord.seismicSensorType / (float)204.8); }
// Check if an older unit doesn't have the Analog Channel Config set
if ((g_factorySetupRecord.analogChannelConfig != CHANNELS_R_AND_V_SCHEMATIC) && (g_factorySetupRecord.analogChannelConfig != CHANNELS_R_AND_V_SWAPPED))
{
// Set the default
g_factorySetupRecord.analogChannelConfig = CHANNELS_R_AND_V_SWAPPED;
}
debug("Factory Setup: Serial #: %s\r\n", g_factorySetupRecord.unitSerialNumber);
debug("Factory Setup: Cal Date: %s\r\n", buff);
debug("Factory Setup: Sensor Type: %s\r\n", (char*)g_spareBuffer);
debug("Factory Setup: A-Weighting: %s\r\n", (g_factorySetupRecord.aWeightOption == YES) ? "Enabled" : "Disabled");
debug("Factory Setup: Analog Channel Config: %s\r\n", (g_factorySetupRecord.analogChannelConfig == CHANNELS_R_AND_V_SCHEMATIC) ? "Schematic" : "Swapped");
}
}
