/**
* @brief Entry point to start execution at
*
* This is the main entry point where execution will start. It initializes the
* hardware and enters an infinite loop handling any upcoming events not yet
* covered.
*
* @note This function makes use of the attribute "OS_main". For details
* refer to [1].
*
* [1]: http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
*
* @return Should never return anything
*/
__attribute__((OS_main)) int main()
{
uart_init();
log_main("Init...\n");
preferences_init();
#if (ENABLE_DCF_SUPPORT == 1)
dcf77_init();
#endif
display_init();
datetime_init();
ldr_init();
pwm_init();
irmp_init();
timer_init();
user_init();
sei();
pwm_on();
log_main("Init finished\n");
while (1) {
brightness_handle();
datetime_handle();
handle_ir_code();
#if (ENABLE_UART_PROTOCOL == 1)
uart_protocol_handle();
#endif /* (ENABLE_UART_PROTOCOL == 1) */
#if (ENABLE_DCF_SUPPORT == 1)
datetime_t dt;
// TODO: Make sure dcf77_getDateTime() validates its result
if (dcf77_get_datetime(&dt)) {
datetime_set(&dt);
}
#endif
}
}
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* MAIN: main routine
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
//int main(void) __attribute__((noreturn)); /* saves some Bytes but produces warning */
int
main (void)
{
static DATETIME datetime;
uart_init(); // initialize uart
log_main("Init...\n");
wcEeprom_init();
# if (DCF_PRESENT == 1)
dcf77_init (); // initialize dcf77
# endif
display_init (); // initialize display
{ // local to save stack
uint8_t i2c_errorcode;
uint8_t i2c_status;
if (! i2c_rtc_init (&i2c_errorcode, &i2c_status)) // initialize rtc
{
log_main("RTC init failed\n");
// TODO: error handling
}
}
ldr_init (); // initialize ldr
pwm_init (); // initialize pwm
irmp_init (); // initialize irmp
timer_init (); // initialize timer
user_init();
sei (); // enable interrupts
pwm_on (); // switch on pwm
//pwm_set_base_brightness_step(MAX_PWM_STEPS-1); /// @todo remove if ldr stuff is working
log_main("Init finished\n");
for (;;)
{
handle_brightness ();
handle_datetime (&datetime); // check & display new time, if necessary
handle_ir_code (); // handle ir user interaction
# if (DCF_PRESENT == 1)
if (dcf77_getDateTime (&datetime)) // handle dcf77 examination (enable_dcf77_ISR must be TRUE to enable analysis)
{
i2c_rtc_write (&datetime);
soft_seconds = datetime.ss;
user_setNewTime (&datetime);
}
# endif /** (DCF_PRESENT == 1) */
}
}
int main(void)
{
// Initialize system upon power-up.
serial_init(); // Setup serial baud rate and interrupts
settings_init(); // Load grbl settings from EEPROM
stepper_init(); // Configure stepper pins and interrupt timers
system_init(); // Configure pinout pins and pin-change interrupt
ldr_init(); //Setup the ADC
memset(&sys, 0, sizeof(sys)); // Clear all system variables
sys.abort = true; // Set abort to complete initialization
sei(); // Enable interrupts
// Check for power-up and set system alarm if homing is enabled to force homing cycle
// by setting Grbl's alarm state. Alarm locks out all g-code commands, including the
// startup scripts, but allows access to settings and internal commands. Only a homing
// cycle '$H' or kill alarm locks '$X' will disable the alarm.
// NOTE: The startup script will run after successful completion of the homing cycle, but
// not after disabling the alarm locks. Prevents motion startup blocks from crashing into
// things uncontrollably. Very bad.
#ifdef HOMING_INIT_LOCK
if (bit_istrue(settings.flags,BITFLAG_HOMING_ENABLE)) { sys.state = STATE_ALARM; }
#endif
// Grbl initialization loop upon power-up or a system abort. For the latter, all processes
// will return to this loop to be cleanly re-initialized.
for(;;) {
// TODO: Separate configure task that require interrupts to be disabled, especially upon
// a system abort and ensuring any active interrupts are cleanly reset.
// Reset Grbl primary systems.
serial_reset_read_buffer(); // Clear serial read buffer
gc_init(); // Set g-code parser to default state
laser_init();
probe_init();
plan_reset(); // Clear block buffer and planner variables
st_reset(); // Clear stepper subsystem variables.
// Sync cleared gcode and planner positions to current system position.
plan_sync_position();
gc_sync_position();
// Reset system variables.
sys.abort = false;
sys.execute = 0;
if (bit_istrue(settings.flags,BITFLAG_AUTO_START)) { sys.auto_start = true; }
else { sys.auto_start = false; }
// Start Grbl main loop. Processes program inputs and executes them.
protocol_main_loop();
}
return 0; /* Never reached */
}
/*
* loaddb_internal - internal main loaddb function
* return: NO_ERROR if successful, error code otherwise
* argc(in): argc of main
* argv(in): argv of main
* dba_mode(in):
*/
static int
loaddb_internal (UTIL_FUNCTION_ARG * arg, int dba_mode)
{
UTIL_ARG_MAP *arg_map = arg->arg_map;
int error = NO_ERROR;
/* set to static to avoid copiler warning (clobbered by longjump) */
static FILE *schema_file = NULL;
static FILE *index_file = NULL;
static FILE *object_file = NULL;
FILE *error_file = NULL;
int status = 0;
int errors, objects, defaults;
#if !defined (LDR_OLD_LOADDB)
int lastcommit = 0;
#endif /* !LDR_OLD_LOADDB */
char *passwd;
/* set to static to avoid copiler warning (clobbered by longjump) */
static int interrupted = false;
int au_save = 0;
extern bool obt_Enable_autoincrement;
char log_file_name[PATH_MAX];
LOADDB_INIT_DEBUG ();
obt_Enable_autoincrement = false;
Volume = utility_get_option_string_value (arg_map, OPTION_STRING_TABLE, 0);
Input_file = utility_get_option_string_value (arg_map, OPTION_STRING_TABLE,
1);
User_name = utility_get_option_string_value (arg_map, LOAD_USER_S, 0);
Password = utility_get_option_string_value (arg_map, LOAD_PASSWORD_S, 0);
Syntax_check = utility_get_option_bool_value (arg_map, LOAD_CHECK_ONLY_S);
Load_only = utility_get_option_bool_value (arg_map, LOAD_LOAD_ONLY_S);
Estimated_size = utility_get_option_int_value (arg_map,
LOAD_ESTIMATED_SIZE_S);
Verbose = utility_get_option_bool_value (arg_map, LOAD_VERBOSE_S);
Disable_statistics =
utility_get_option_bool_value (arg_map, LOAD_NO_STATISTICS_S);
Periodic_commit = utility_get_option_int_value (arg_map,
LOAD_PERIODIC_COMMIT_S);
Verbose_commit = Periodic_commit > 0 ? true : false;
No_oid_hint = utility_get_option_bool_value (arg_map, LOAD_NO_OID_S);
Schema_file = utility_get_option_string_value (arg_map, LOAD_SCHEMA_FILE_S,
0);
Index_file = utility_get_option_string_value (arg_map, LOAD_INDEX_FILE_S,
0);
Object_file = utility_get_option_string_value (arg_map, LOAD_DATA_FILE_S,
0);
Error_file = utility_get_option_string_value (arg_map,
LOAD_ERROR_CONTROL_FILE_S, 0);
Ignore_logging = utility_get_option_bool_value (arg_map,
LOAD_IGNORE_LOGGING_S);
#if !defined (LDR_OLD_LOADDB)
Ignore_class_file = utility_get_option_string_value (arg_map,
LOAD_IGNORE_CLASS_S,
0);
#endif
Input_file = Input_file ? Input_file : "";
Schema_file = Schema_file ? Schema_file : "";
Index_file = Index_file ? Index_file : "";
Object_file = Object_file ? Object_file : "";
Error_file = Error_file ? Error_file : "";
if (ldr_validate_object_file (stderr, arg->argv0))
{
goto error_return;
}
/* error message log file */
sprintf (log_file_name, "%s_%s.err", Volume, arg->command_name);
er_init (log_file_name, ER_NEVER_EXIT);
if (Index_file[0] != '\0'
&& PRM_SR_NBUFFERS < LOAD_INDEX_MIN_SORT_BUFFER_PAGES)
{
sysprm_set_force (PRM_NAME_SR_NBUFFERS,
LOAD_INDEX_MIN_SORT_BUFFER_PAGES_STRING);
}
sysprm_set_force (PRM_NAME_JAVA_STORED_PROCEDURE, "no");
/* login */
if (User_name != NULL || !dba_mode)
{
(void) db_login (User_name, Password);
if ((error = db_restart (arg->command_name, true, Volume)))
{
if (error == ER_AU_INVALID_PASSWORD)
{
/* prompt for password and try again */
error = NO_ERROR;
passwd = getpass (msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_PASSWORD_PROMPT));
if (!strlen (passwd))
passwd = NULL;
(void) db_login (User_name, passwd);
error = db_restart (arg->command_name, true, Volume);
}
}
}
else
{
/* if we're in the protected dba mode, just login without
authorization */
AU_DISABLE_PASSWORDS ();
db_set_client_type (DB_CLIENT_TYPE_ADMIN_UTILITY);
(void) db_login ("dba", NULL);
error = db_restart (arg->command_name, true, Volume);
}
/* open loaddb log file */
sprintf (log_file_name, "%s_loaddb.log", Volume);
loaddb_log_file = fopen (log_file_name, "w+");
if (loaddb_log_file == NULL)
{
printf ("Cannot open log file %s\n", log_file_name);
status = 2;
goto error_return;
}
#if 0
#if !defined (LDR_OLD_LOADDB)
/* Execute old loaddb if no optimization flag is set true
* or LOADDB_NOPT is set, we must pass the argv except
* -no option and invoke execvp() for no optimized loaddb
*/
if (No_optimization || envvar_get ("LOADDB_NOPT"))
{
char **tmp;
char *lastslash, path[PATH_MAX];
int i = 1, j = 1;
tmp = (char **) malloc (sizeof (char *) * (argc + 1));
tmp[0] = (char *) "loaddb";
while (j < argc)
{
if (!strcmp (argv[j], "-no"))
j++;
else
tmp[i++] = argv[j++];
};
tmp[i] = 0;
strcpy (path, argv[0]);
lastslash = strrchr (path, (int) '/');
#if defined(WINDOWS)
{
char *p, exec_path[1024], cmd_line[1024 * 8];
int cp_len = 0;
db_shutdown ();
p = envvar_root ();
if (p == NULL)
{
printf ("The `CUBRID' environment variable is not set.\n");
}
else
{
sprintf (exec_path, "%s/migdb_o.exe", p);
for (i = 0; tmp[i]; i++)
{
cp_len += sprintf (cmd_line + cp_len, "\"%s\" ", tmp[i]);
}
if (envvar_get ("FRONT_DEBUG") != NULL)
{
printf ("Executing:%s %s\n", exec_path, cmd_line);
}
run_proc (exec_path, cmd_line);
}
exit (0);
}
#else /* !WINDOWS */
if (lastslash != NULL)
strcpy (lastslash + 1, "migdb_o");
else
strcpy (path, "migdb_o");
if (execvp (path, tmp) == -1)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_NOPT_ERR));
exit (0);
};
#endif /* WINDOWS */
}
#endif /* !LDR_OLD_LOADDB */
#endif
/* check if schema/index/object files exist */
ldr_check_file_name_and_line_no ();
if (Schema_file[0] != 0)
{
schema_file = fopen (Schema_file, "r");
if (schema_file == NULL)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_BAD_INFILE),
Schema_file);
status = 2;
goto error_return;
}
}
if (Index_file[0] != 0)
{
index_file = fopen (Index_file, "r");
if (index_file == NULL)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_BAD_INFILE),
Index_file);
status = 2;
goto error_return;
}
}
if (Object_file[0] != 0)
{
object_file = fopen_ex (Object_file, "rb"); /* keep out ^Z */
if (object_file == NULL)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_BAD_INFILE),
Object_file);
status = 2;
goto error_return;
}
}
#if !defined (LDR_OLD_LOADDB)
if (Ignore_class_file)
{
int retval;
retval = get_ignore_class_list (Ignore_class_file);
if (retval < 0)
{
status = 2;
goto error_return;
}
}
#endif
/* Disallow syntax only and load only options together */
if (Load_only && Syntax_check)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_INCOMPATIBLE_ARGS),
"--" LOAD_LOAD_ONLY_L, "--" LOAD_CHECK_ONLY_L);
status = 1; /* parsing error */
goto error_return;
}
if (Error_file[0] != 0)
{
if (Syntax_check)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_INCOMPATIBLE_ARGS),
"--" LOAD_ERROR_CONTROL_FILE_L,
"--" LOAD_CHECK_ONLY_L);
status = 1; /* parsing error */
goto error_return;
}
error_file = fopen_ex (Error_file, "rt");
if (error_file == NULL)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_BAD_INFILE),
Error_file);
status = 2;
goto error_return;
}
er_filter_fileset (error_file);
fclose (error_file);
}
/* check if no log option can be applied */
if (error
|| (Ignore_logging != 0 && locator_log_force_nologging () != NO_ERROR))
{
/* couldn't log in */
print_log_msg (1, "%s\n", db_error_string (3));
status = 3;
db_shutdown ();
goto error_return;
}
/* change "print_key_value_on_unique_error" parameter */
sysprm_change_server_parameters ("print_key_value_on_unique_error=1");
/* if schema file is specified, do schema loading */
if (schema_file != NULL)
{
print_log_msg (1, "\nStart schema loading.\n");
/*
* CUBRID 8.2 should be compatible with earlier versions of CUBRID.
* Therefore, we do not perform user authentication when the loader
* is executing by DBA group user.
*/
if (au_is_dba_group_member (Au_user))
{
AU_DISABLE (au_save);
}
if (ldr_exec_query_from_file (Schema_file, schema_file,
&schema_file_start_line,
Periodic_commit) != 0)
{
print_log_msg (1, "\nError occurred during schema loading."
"\nAborting current transaction...");
status = 3;
db_shutdown ();
print_log_msg (1,
" done.\n\nRestart loaddb with '-%c %s:%d' option\n",
LOAD_SCHEMA_FILE_S, Schema_file,
schema_file_start_line);
goto error_return;
}
if (au_is_dba_group_member (Au_user))
{
AU_ENABLE (au_save);
}
print_log_msg (1, "Schema loading from %s finished.\n", Schema_file);
/* update catalog statistics */
AU_DISABLE (au_save);
sm_update_all_catalog_statistics ();
AU_ENABLE (au_save);
print_log_msg (1,
"Statistics for Catalog classes have been updated.\n\n");
db_commit_transaction ();
fclose (schema_file);
schema_file = NULL;
}
/* if index file is specified, do index creation */
if (object_file != NULL)
{
#if defined (SA_MODE)
locator_Dont_check_foreign_key = true;
#endif
print_log_msg (1, "\nStart object loading.\n");
ldr_init (Verbose);
/* set the flag to indicate what type of interrupts to raise
* If logging has been disabled set commit flag.
* If logging is enabled set abort flag.
*/
if (Ignore_logging)
Interrupt_type = LDR_STOP_AND_COMMIT_INTERRUPT;
else
Interrupt_type = LDR_STOP_AND_ABORT_INTERRUPT;
if (Periodic_commit)
{
/* register the post commit function */
#if defined(LDR_OLD_LOADDB)
ldr_register_post_commit_handler (&loaddb_report_num_of_commits);
#else /* !LDR_OLD_LOADDB */
ldr_register_post_commit_handler (&loaddb_report_num_of_commits,
NULL);
#endif /* LDR_OLD_LOADDB */
}
/* Check if we need to perform syntax checking. */
if (!Load_only)
{
print_log_msg ((int) Verbose, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_CHECKING));
do_loader_parse (object_file);
#if defined(LDR_OLD_LOADDB)
ldr_stats (&errors, &objects, &defaults);
#else /* !LDR_OLD_LOADDB */
ldr_stats (&errors, &objects, &defaults, &lastcommit);
#endif /* LDR_OLD_LOADDB */
}
else
errors = 0;
if (errors)
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_ERROR_COUNT), errors);
else if (!Syntax_check)
{
/* now do it for real if there were no errors and we aren't
doing a simple syntax check */
ldr_start (Periodic_commit);
fclose (object_file);
object_file = fopen_ex (Object_file, "rb"); /* keep out ^Z */
if (object_file != NULL)
{
print_log_msg ((int) Verbose,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_INSERTING));
/* make sure signals are caught */
util_arm_signal_handlers (signal_handler, signal_handler);
/* register function to call and jmp environment to longjmp to
* after aborting or committing.
*/
ldr_register_post_interrupt_handler
(&loaddb_get_num_of_inserted_objects, &loaddb_jmp_buf);
if (setjmp (loaddb_jmp_buf) != 0)
{
/* We have had an interrupt, the transaction should have
* been already been aborted or committed by the loader.
* If Total_objects_loaded is -1 an error occurred during
* rollback or commit.
*/
if (Total_objects_loaded != -1)
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_OBJECT_COUNT),
Total_objects_loaded);
#if !defined(LDR_OLD_LOADDB)
ldr_stats (&errors, &objects, &defaults, &lastcommit);
if (lastcommit > 0)
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_LAST_COMMITTED_LINE),
lastcommit);
#endif /* !LDR_OLD_LOADDB */
interrupted = true;
}
else
{
do_loader_parse (object_file);
#if defined(LDR_OLD_LOADDB)
ldr_stats (&errors, &objects, &defaults);
#else /* !LDR_OLD_LOADDB */
ldr_stats (&errors, &objects, &defaults, &lastcommit);
#endif /* LDR_OLD_LOADDB */
if (errors)
{
#if defined(LDR_OLD_LOADDB)
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_ERROR_COUNT),
errors);
#else /* !LDR_OLD_LOADDB */
if (lastcommit > 0)
print_log_msg (1,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_LAST_COMMITTED_LINE),
lastcommit);
#endif /* LDR_OLD_LOADDB */
/*
* don't allow the transaction to be committed at
* this point, note that if we ever move to a scheme
* where we write directly to the heap without the
* transaction context, we will have to unwind the
* changes made if errors are detected !
*/
db_abort_transaction ();
}
else
{
if (objects)
print_log_msg (1,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_OBJECT_COUNT),
objects);
if (defaults)
print_log_msg (1,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_DEFAULT_COUNT),
defaults);
print_log_msg ((int) Verbose,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_COMMITTING));
/* commit the transaction and then update statistics */
if (!db_commit_transaction ())
{
if (!Disable_statistics)
{
if (Verbose)
print_log_msg (1,
msgcat_message
(MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_UPDATING_STATISTICS));
if (!ldr_update_statistics ())
{
/*
* would it be faster to update statistics
* before the first commit and just have a
* single commit ?
*/
print_log_msg ((int) Verbose,
msgcat_message
(MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_COMMITTING));
(void) db_commit_transaction ();
}
}
}
}
}
}
}
ldr_final ();
if (object_file != NULL)
{
fclose (object_file);
object_file = NULL;
}
}
/* create index */
if (!interrupted && index_file != NULL)
{
print_log_msg (1, "\nStart index loading.\n");
if (ldr_exec_query_from_file (Index_file, index_file,
&index_file_start_line,
Periodic_commit) != 0)
{
print_log_msg (1, "\nError occurred during index loading."
"\nAborting current transaction...");
status = 3;
db_shutdown ();
print_log_msg (1,
" done.\n\nRestart loaddb with '-%c %s:%d' option\n",
LOAD_INDEX_FILE_S, Index_file,
index_file_start_line);
goto error_return;
}
/* update catalog statistics */
AU_DISABLE (au_save);
sm_update_catalog_statistics (CT_INDEX_NAME);
sm_update_catalog_statistics (CT_INDEXKEY_NAME);
AU_ENABLE (au_save);
print_log_msg (1, "Index loading from %s finished.\n", Index_file);
db_commit_transaction ();
}
print_log_msg ((int) Verbose, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_CLOSING));
(void) db_shutdown ();
#if !defined (LDR_OLD_LOADDB)
free_ignoreclasslist ();
#endif
return (status);
error_return:
if (schema_file != NULL)
fclose (schema_file);
if (object_file != NULL)
fclose (object_file);
if (index_file != NULL)
fclose (index_file);
#if !defined (LDR_OLD_LOADDB)
free_ignoreclasslist ();
#endif
return status;
}
void cmd_lcd_test(uint_least16_t fgcolor, uint_least16_t bgcolor)
{
uint_least8_t c=1, f_save=features;
char tmp[32];
#ifdef TP_SUPPORT
uint_least16_t x, y, z, last_x=0, last_y=0;
uint_least32_t ms=0;
tp_init();
ldr_init();
features = FEATURE_TP | FEATURE_LDR; //FEATURE_TP | FEATURE_LDR
#else
uint_least8_t sw;
int_least8_t pos=0, hpos=0, vpos=0;
enc_init();
features = FEATURE_ENC;
#endif
lcd_fillrect(0, 0, (LCD_WIDTH-1)/3, LCD_HEIGHT-1, RGB(255,0,0));
lcd_fillrect((LCD_WIDTH-1)/3, 0, ((LCD_WIDTH-1)/3)*2, LCD_HEIGHT-1, RGB(0,255,0));
lcd_fillrect(((LCD_WIDTH-1)/3)*2, 0, LCD_WIDTH-1, LCD_HEIGHT-1, RGB(0,0,255));
/*
delay_ms(1500);
lcd_clear(bgcolor);
lcd_setorientation( 0); lcd_drawrect(10, 20, 40, 40, RGB(200, 0, 0)); lcd_drawtext(15, 25, "0 ", 0, RGB(200, 0, 0), 0, 0);
lcd_setorientation( 90); lcd_drawrect(10, 20, 40, 40, RGB( 0,200, 0)); lcd_drawtext(15, 25, "90 ", 0, RGB( 0,200, 0), 0, 0);
lcd_setorientation(180); lcd_drawrect(10, 20, 40, 40, RGB( 0, 0,200)); lcd_drawtext(15, 25, "180", 0, RGB( 0, 0,200), 0, 0);
lcd_setorientation(270); lcd_drawrect(10, 20, 40, 40, RGB(200, 0,200)); lcd_drawtext(15, 25, "270", 0, RGB(200, 0,200), 0, 0);
lcd_setorientation(0);
lcd_drawline(0, LCD_WIDTH/4*1, LCD_WIDTH-1, LCD_WIDTH/4*1, RGB(120,120,120));
lcd_drawline(0, LCD_WIDTH/4*2, LCD_WIDTH-1, LCD_WIDTH/4*2, RGB(120,120,120));
lcd_drawline(0, LCD_WIDTH/4*3, LCD_WIDTH-1, LCD_WIDTH/4*3, RGB(120,120,120));
lcd_drawline(LCD_WIDTH/4*1, 0, LCD_WIDTH/4*1, LCD_HEIGHT-1, RGB(120,120,120));
lcd_drawline(LCD_WIDTH/4*2, 0, LCD_WIDTH/4*2, LCD_HEIGHT-1, RGB(120,120,120));
lcd_drawline(LCD_WIDTH/4*3, 0, LCD_WIDTH/4*3, LCD_HEIGHT-1, RGB(120,120,120));
lcd_drawcircle(LCD_WIDTH/2, LCD_HEIGHT/2, 40, RGB(120,120,120));
*/
lcd_drawtext(LCD_CENTER, LCD_HEIGHT/2-5, "v"VERSION, 0, 0, 0, 0);
lcd_drawtext(LCD_CENTER, LCD_HEIGHT/2+5, "("__DATE__")", 0, 0, 0, 0);
lcd_drawtext(LCD_CENTER, LCD_HEIGHT-10, "watterott.com", 1, 0, 0, 0);
do
{
#ifdef TP_SUPPORT
tp_read();
z = tp_getz();
if(z)
{
x = tp_getx();
y = tp_gety();
if((x!=last_x) || (y!=last_y))
{
last_x = x;
last_y = y;
lcd_fillcircle(x, y, 4, fgcolor); //lcd_drawpixel(x, y);
sprintf(tmp, "X%03i Y%03i Z%03i", x, x, z);
lcd_drawtext(5, 5, tmp, 0, fgcolor, bgcolor, 1);
}
GPIO_SETPIN(LED_PORT, LED_PIN); //LED on
}
else
{
GPIO_CLRPIN(LED_PORT, LED_PIN); //LED off
}
if(features & FEATURE_LDR)
{
if((get_ms() - ms) >= 100)
{
ms = get_ms();
x = ldr_service(100);
sprintf(tmp, "LDR %03i", x);
lcd_drawtext(5, 15, tmp, 0, fgcolor, bgcolor, 1);
}
}
#else //TP_SUPPORT
pos += enc_getdelta();
hpos += nav_gethdelta();
vpos += nav_getvdelta();
sprintf(tmp, "P%03i H%03i V%03i", pos, hpos, vpos);
lcd_drawtext(5, 5, tmp, 0, fgcolor, bgcolor, 1);
sw = enc_getsw();
sw |= nav_getsw();
if(sw)
{
GPIO_SETPIN(LED_PORT, LED_PIN); //LED on
if(sw & 0x02)
{
if(features == FEATURE_ENC)
{
sprintf(tmp, "NAV");
nav_init();
features = FEATURE_NAV;
}
else //if(features == FEATURE_NAV)
{
sprintf(tmp, "ENC");
enc_init();
features = FEATURE_ENC;
}
lcd_drawtext(5, 25, tmp, 0, fgcolor, bgcolor, 1);
delay_ms(500);
while(enc_getsw() || nav_getsw());
}
else if(sw & 0x01)
{
lcd_drawtext(5, 15, "press", 0, fgcolor, bgcolor, 1);
}
}
else
{
GPIO_CLRPIN(LED_PORT, LED_PIN); //LED off
}
#endif
if(if_available())
{
c = if_read8();
}
}while(c != 0);
GPIO_CLRPIN(LED_PORT, LED_PIN); //LED off
lcd_clear(bgcolor);
features = f_save;
return;
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
* main function
*-------------------------------------------------------------------------------------------------------------------------------------------
*/
int
main ()
{
static uint_fast8_t last_ldr_value = 0xFF;
struct tm tm;
LISTENER_DATA lis;
ESP8266_INFO * esp8266_infop;
uint_fast8_t esp8266_is_up = 0;
uint_fast8_t code;
#if SAVE_RAM == 0
IRMP_DATA irmp_data;
uint32_t stop_time;
uint_fast8_t cmd;
#endif
uint_fast8_t status_led_cnt = 0;
uint_fast8_t display_flag = DISPLAY_FLAG_UPDATE_ALL;
uint_fast8_t show_temperature = 0;
uint_fast8_t time_changed = 0;
uint_fast8_t power_is_on = 1;
uint_fast8_t night_power_is_on = 1;
uint_fast8_t ldr_value;
uint_fast8_t ap_mode = 0;
SystemInit ();
SystemCoreClockUpdate(); // needed for Nucleo board
#if defined (STM32F103) // disable JTAG to get back PB3, PB4, PA13, PA14, PA15
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); // turn on clock for the alternate function register
GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE); // disable the JTAG, enable the SWJ interface
#endif
log_init (); // initilize logger on uart
#if SAVE_RAM == 0
irmp_init (); // initialize IRMP
#endif
timer2_init (); // initialize timer2 for IRMP, DCF77, EEPROM etc.
delay_init (DELAY_RESOLUTION_1_US); // initialize delay functions with granularity of 1 us
board_led_init (); // initialize GPIO for green LED on disco or nucleo board
button_init (); // initialize GPIO for user button on disco or nucleo board
rtc_init (); // initialize I2C RTC
eeprom_init (); // initialize I2C EEPROM
if (button_pressed ()) // set ESP8266 into flash mode
{
board_led_on ();
esp8266_flash ();
}
log_msg ("\r\nWelcome to WordClock Logger!");
log_msg ("----------------------------");
log_str ("Version: ");
log_msg (VERSION);
if (rtc_is_up)
{
log_msg ("rtc is online");
}
else
{
log_msg ("rtc is offline");
}
if (eeprom_is_up)
{
log_msg ("eeprom is online");
read_version_from_eeprom ();
log_printf ("current eeprom version: 0x%08x\r\n", eeprom_version);
if ((eeprom_version & 0xFF0000FF) == 0x00000000)
{ // Upper and Lower Byte must be 0x00
if (eeprom_version >= EEPROM_VERSION_1_5_0)
{
#if SAVE_RAM == 0
log_msg ("reading ir codes from eeprom");
remote_ir_read_codes_from_eeprom ();
#endif
log_msg ("reading display configuration from eeprom");
display_read_config_from_eeprom ();
log_msg ("reading timeserver data from eeprom");
timeserver_read_data_from_eeprom ();
}
if (eeprom_version >= EEPROM_VERSION_1_7_0)
{
log_msg ("reading night timers from eeprom");
night_read_data_from_eeprom ();
}
}
}
else
{
log_msg ("eeprom is offline");
}
ldr_init (); // initialize LDR (ADC)
display_init (); // initialize display
dcf77_init (); // initialize DCF77
night_init (); // initialize night time routines
short_isr = 1;
temp_init (); // initialize DS18xx
short_isr = 0;
display_reset_led_states ();
display_mode = display_get_display_mode ();
animation_mode = display_get_animation_mode ();
auto_brightness = display_get_automatic_brightness_control ();
if (eeprom_is_up)
{
if (eeprom_version != EEPROM_VERSION)
{
log_printf ("updating EEPROM to version 0x%08x\r\n", EEPROM_VERSION);
eeprom_version = EEPROM_VERSION;
write_version_to_eeprom ();
#if SAVE_RAM == 0
remote_ir_write_codes_to_eeprom ();
#endif
display_write_config_to_eeprom ();
timeserver_write_data_to_eeprom ();
night_write_data_to_eeprom ();
eeprom_version = EEPROM_VERSION;
}
}
ds3231_flag = 1;
#if SAVE_RAM == 0
stop_time = uptime + 3; // wait 3 seconds for IR signal...
display_set_status_led (1, 1, 1); // show white status LED
while (uptime < stop_time)
{
if (irmp_get_data (&irmp_data)) // got IR signal?
{
display_set_status_led (1, 0, 0); // yes, show red status LED
delay_sec (1); // and wait 1 second
(void) irmp_get_data (&irmp_data); // flush input of IRMP now
display_set_status_led (0, 0, 0); // and switch status LED off
log_msg ("calling IR learn function");
if (remote_ir_learn ()) // learn IR commands
{
remote_ir_write_codes_to_eeprom (); // if successful, save them in EEPROM
}
break; // and break the loop
}
}
#endif
display_set_status_led (0, 0, 0); // switch off status LED
esp8266_init ();
esp8266_infop = esp8266_get_info ();
while (1)
{
if (! ap_mode && esp8266_is_up && button_pressed ()) // if user pressed user button, set ESP8266 to AP mode
{
ap_mode = 1;
log_msg ("user button pressed: configuring esp8266 as access point");
esp8266_is_online = 0;
esp8266_infop->is_online = 0;
esp8266_infop->ipaddress[0] = '\0';
esp8266_accesspoint ("wordclock", "1234567890");
}
if (status_led_cnt)
{
status_led_cnt--;
if (! status_led_cnt)
{
display_set_status_led (0, 0, 0);
}
}
if ((code = listener (&lis)) != 0)
{
display_set_status_led (1, 0, 0); // got net command, light red status LED
status_led_cnt = STATUS_LED_FLASH_TIME;
switch (code)
{
case LISTENER_SET_COLOR_CODE: // set color
{
display_set_colors (&(lis.rgb));
log_printf ("command: set colors to %d %d %d\r\n", lis.rgb.red, lis.rgb.green, lis.rgb.blue);
break;
}
case LISTENER_POWER_CODE: // power on/off
{
if (power_is_on != lis.power)
{
power_is_on = lis.power;
display_flag = DISPLAY_FLAG_UPDATE_ALL;
log_msg ("command: set power");
}
break;
}
case LISTENER_DISPLAY_MODE_CODE: // set display mode
{
if (display_mode != lis.mode)
{
display_mode = display_set_display_mode (lis.mode);
display_flag = DISPLAY_FLAG_UPDATE_ALL;
log_printf ("command: set display mode to %d\r\n", display_mode);
}
break;
}
case LISTENER_ANIMATION_MODE_CODE: // set animation mode
{
if (animation_mode != lis.mode)
{
animation_mode = display_set_animation_mode (lis.mode);
animation_flag = 0;
display_flag = DISPLAY_FLAG_UPDATE_ALL;
log_printf ("command: set animation mode to %d\r\n", animation_flag);
}
break;
}
case LISTENER_DISPLAY_TEMPERATURE_CODE: // set animation mode
{
show_temperature = 1;
log_msg ("command: show temperature");
break;
}
case LISTENER_SET_BRIGHTNESS_CODE: // set brightness
{
if (auto_brightness)
{
auto_brightness = 0;
last_ldr_value = 0xFF;
display_set_automatic_brightness_control (auto_brightness);
}
display_set_brightness (lis.brightness);
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
log_printf ("command: set brightness to %d, disable autmomatic brightness control per LDR\r\n", lis.brightness);
break;
}
case LISTENER_SET_AUTOMATIC_BRIHGHTNESS_CODE: // automatic brightness control on/off
{
if (lis.automatic_brightness_control)
{
auto_brightness = 1;
log_msg ("command: enable automatic brightness control");
}
else
{
auto_brightness = 0;
log_msg ("command: disable automatic brightness control");
}
last_ldr_value = 0xFF;
display_set_automatic_brightness_control (auto_brightness);
break;
}
case LISTENER_TEST_DISPLAY_CODE: // test display
{
log_msg ("command: start display test");
display_test ();
break;
}
case LISTENER_SET_DATE_TIME_CODE: // set date/time
{
if (rtc_is_up)
{
rtc_set_date_time (&(lis.tm));
}
if (hour != (uint_fast8_t) lis.tm.tm_hour || minute != (uint_fast8_t) lis.tm.tm_min)
{
display_flag = DISPLAY_FLAG_UPDATE_ALL;
}
wday = lis.tm.tm_wday;
hour = lis.tm.tm_hour;
minute = lis.tm.tm_min;
second = lis.tm.tm_sec;
log_printf ("command: set time to %s %4d-%02d-%02d %02d:%02d:%02d\r\n",
wdays_en[lis.tm.tm_wday], lis.tm.tm_year + 1900, lis.tm.tm_mon + 1, lis.tm.tm_mday,
lis.tm.tm_hour, lis.tm.tm_min, lis.tm.tm_sec);
break;
}
case LISTENER_GET_NET_TIME_CODE: // get net time
{
net_time_flag = 1;
log_msg ("command: start net time request");
break;
}
case LISTENER_IR_LEARN_CODE: // IR learn
{
#if SAVE_RAM == 0
log_msg ("command: learn IR codes");
if (remote_ir_learn ())
{
remote_ir_write_codes_to_eeprom ();
}
#endif
break;
}
case LISTENER_SAVE_DISPLAY_CONFIGURATION: // save display configuration
{
display_write_config_to_eeprom ();
log_msg ("command: save display settings");
break;
}
}
}
if (auto_brightness && ldr_poll_brightness (&ldr_value))
{
if (ldr_value + 1 < last_ldr_value || ldr_value > last_ldr_value + 1) // difference greater than 2
{
log_printf ("ldr: old brightnes: %d new brightness: %d\r\n", last_ldr_value, ldr_value);
last_ldr_value = ldr_value;
display_set_brightness (ldr_value);
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
}
}
if (!esp8266_is_up) // esp8266 up yet?
{
if (esp8266_infop->is_up)
{
esp8266_is_up = 1;
log_msg ("esp8266 now up");
}
}
else
{ // esp8266 is up...
if (! esp8266_is_online) // but not online yet...
{
if (esp8266_infop->is_online) // now online?
{
char buf[32];
esp8266_is_online = 1;
log_msg ("esp8266 now online");
sprintf (buf, " IP %s", esp8266_infop->ipaddress);
display_banner (buf);
display_flag = DISPLAY_FLAG_UPDATE_ALL;
net_time_flag = 1;
}
}
}
if (dcf77_time(&tm))
{
display_set_status_led (1, 1, 0); // got DCF77 time, light yellow = green + red LED
status_led_cnt = 50;
if (rtc_is_up)
{
rtc_set_date_time (&tm);
}
if (hour != (uint_fast8_t) tm.tm_hour || minute != (uint_fast8_t) tm.tm_min)
{
display_flag = DISPLAY_FLAG_UPDATE_ALL;
}
wday = tm.tm_wday;
hour = tm.tm_hour;
minute = tm.tm_min;
second = tm.tm_sec;
log_printf ("dcf77: %s %4d-%02d-%02d %02d:%02d:%02d\r\n",
wdays_en[tm.tm_wday], tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
}
if (ds3231_flag)
{
if (rtc_is_up && rtc_get_date_time (&tm))
{
if (hour != (uint_fast8_t) tm.tm_hour || minute != (uint_fast8_t) tm.tm_min)
{
display_flag = DISPLAY_FLAG_UPDATE_ALL;
}
wday = tm.tm_wday;
hour = tm.tm_hour;
minute = tm.tm_min;
second = tm.tm_sec;
log_printf ("read rtc: %s %4d-%02d-%02d %02d:%02d:%02d\r\n",
wdays_en[tm.tm_wday], tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
}
ds3231_flag = 0;
}
if (auto_brightness && ldr_conversion_flag)
{
ldr_start_conversion ();
ldr_conversion_flag = 0;
}
if (net_time_flag)
{
if (esp8266_infop->is_online)
{
display_set_status_led (0, 0, 1); // light blue status LED
status_led_cnt = STATUS_LED_FLASH_TIME;
timeserver_start_timeserver_request (); // start a timeserver request, answer follows...
}
net_time_flag = 0;
net_time_countdown = 3800; // next net time after 3800 sec
}
if (show_time_flag) // set every full minute
{
#if WCLOCK24H == 1
display_flag = DISPLAY_FLAG_UPDATE_ALL;
#else
if (minute % 5)
{
display_flag = DISPLAY_FLAG_UPDATE_MINUTES; // only update minute LEDs
}
else
{
display_flag = DISPLAY_FLAG_UPDATE_ALL;
}
#endif
show_time_flag = 0;
}
if (power_is_on == night_power_is_on && night_check_night_times (power_is_on, wday, hour * 60 + minute))
{
power_is_on = ! power_is_on;
night_power_is_on = ! night_power_is_on;
display_flag = DISPLAY_FLAG_UPDATE_ALL;
log_printf ("Found Timer: %s at %02d:%02d\r\n", power_is_on ? "on" : "off", hour, minute);
}
if (show_temperature)
{
uint_fast8_t temperature_index;
show_temperature = 0;
if (ds18xx_is_up)
{
short_isr = 1;
temperature_index = temp_read_temp_index ();
short_isr = 0;
log_printf ("got temperature from DS18xxx: %d%s\r\n", temperature_index / 2, (temperature_index % 2) ? ".5" : "");
}
else if (rtc_is_up)
{
temperature_index = rtc_get_temperature_index ();
log_printf ("got temperature from RTC: %d%s\r\n", temperature_index / 2, (temperature_index % 2) ? ".5" : "");
}
else
{
temperature_index = 0xFF;
log_msg ("no temperature available");
}
if (temperature_index != 0xFF)
{
display_temperature (power_is_on, temperature_index);
#if WCLOCK24H == 1 // WC24H shows temperature with animation, WC12H rolls itself
uint32_t stop_time;
stop_time = uptime + 5;
while (uptime < stop_time)
{
if (animation_flag)
{
animation_flag = 0;
display_animation ();
}
}
#endif
display_flag = DISPLAY_FLAG_UPDATE_ALL; // force update
}
}
if (display_flag) // refresh display (time/mode changed)
{
log_msg ("update display");
#if WCLOCK24H == 1
if (display_mode == MODES_COUNT - 1) // temperature
{
uint_fast8_t temperature_index;
if (ds18xx_is_up)
{
short_isr = 1;
temperature_index = temp_read_temp_index ();
short_isr = 0;
log_printf ("got temperature from DS18xxx: %d%s\r\n", temperature_index / 2, (temperature_index % 2) ? ".5" : "");
}
else if (rtc_is_up)
{
temperature_index = rtc_get_temperature_index ();
log_printf ("got temperature from RTC: %d%s\r\n", temperature_index / 2, (temperature_index % 2) ? ".5" : "");
}
else
{
temperature_index = 0x00;
log_msg ("no temperature available");
}
display_clock (power_is_on, 0, temperature_index - 20, display_flag); // show new time
}
else
{
display_clock (power_is_on, hour, minute, display_flag); // show new time
}
#else
display_clock (power_is_on, hour, minute, display_flag); // show new time
#endif
display_flag = DISPLAY_FLAG_NONE;
}
if (animation_flag)
{
animation_flag = 0;
display_animation ();
}
if (dcf77_flag)
{
dcf77_flag = 0;
dcf77_tick ();
}
#if SAVE_RAM == 0
cmd = remote_ir_get_cmd (); // get IR command
if (cmd != REMOTE_IR_CMD_INVALID) // got IR command, light green LED
{
display_set_status_led (1, 0, 0);
status_led_cnt = STATUS_LED_FLASH_TIME;
}
if (cmd != REMOTE_IR_CMD_INVALID) // if command valid, log command code
{
switch (cmd)
{
case REMOTE_IR_CMD_POWER: log_msg ("IRMP: POWER key"); break;
case REMOTE_IR_CMD_OK: log_msg ("IRMP: OK key"); break;
case REMOTE_IR_CMD_DECREMENT_DISPLAY_MODE: log_msg ("IRMP: decrement display mode"); break;
case REMOTE_IR_CMD_INCREMENT_DISPLAY_MODE: log_msg ("IRMP: increment display mode"); break;
case REMOTE_IR_CMD_DECREMENT_ANIMATION_MODE: log_msg ("IRMP: decrement animation mode"); break;
case REMOTE_IR_CMD_INCREMENT_ANIMATION_MODE: log_msg ("IRMP: increment animation mode"); break;
case REMOTE_IR_CMD_DECREMENT_HOUR: log_msg ("IRMP: decrement hour"); break;
case REMOTE_IR_CMD_INCREMENT_HOUR: log_msg ("IRMP: increment hour"); break;
case REMOTE_IR_CMD_DECREMENT_MINUTE: log_msg ("IRMP: decrement minute"); break;
case REMOTE_IR_CMD_INCREMENT_MINUTE: log_msg ("IRMP: increment minute"); break;
case REMOTE_IR_CMD_DECREMENT_BRIGHTNESS_RED: log_msg ("IRMP: decrement red brightness"); break;
case REMOTE_IR_CMD_INCREMENT_BRIGHTNESS_RED: log_msg ("IRMP: increment red brightness"); break;
case REMOTE_IR_CMD_DECREMENT_BRIGHTNESS_GREEN: log_msg ("IRMP: decrement green brightness"); break;
case REMOTE_IR_CMD_INCREMENT_BRIGHTNESS_GREEN: log_msg ("IRMP: increment green brightness"); break;
case REMOTE_IR_CMD_DECREMENT_BRIGHTNESS_BLUE: log_msg ("IRMP: decrement blue brightness"); break;
case REMOTE_IR_CMD_INCREMENT_BRIGHTNESS_BLUE: log_msg ("IRMP: increment blue brightness"); break;
case REMOTE_IR_CMD_DECREMENT_BRIGHTNESS: log_msg ("IRMP: decrement brightness"); break;
case REMOTE_IR_CMD_INCREMENT_BRIGHTNESS: log_msg ("IRMP: increment brightness"); break;
case REMOTE_IR_CMD_GET_TEMPERATURE: log_msg ("IRMP: get temperature"); break;
}
}
switch (cmd)
{
case REMOTE_IR_CMD_POWER:
{
power_is_on = ! power_is_on;
display_flag = DISPLAY_FLAG_UPDATE_ALL;
break;
}
case REMOTE_IR_CMD_OK:
{
display_write_config_to_eeprom ();
break;
}
case REMOTE_IR_CMD_DECREMENT_DISPLAY_MODE: // decrement display mode
{
display_mode = display_decrement_display_mode ();
display_flag = DISPLAY_FLAG_UPDATE_ALL;
break;
}
case REMOTE_IR_CMD_INCREMENT_DISPLAY_MODE: // increment display mode
{
display_mode = display_increment_display_mode ();
display_flag = DISPLAY_FLAG_UPDATE_ALL;
break;
}
case REMOTE_IR_CMD_DECREMENT_ANIMATION_MODE: // decrement display mode
{
animation_mode = display_decrement_animation_mode ();
display_flag = DISPLAY_FLAG_UPDATE_ALL;
break;
}
case REMOTE_IR_CMD_INCREMENT_ANIMATION_MODE: // increment display mode
{
animation_mode = display_increment_animation_mode ();
display_flag = DISPLAY_FLAG_UPDATE_ALL;
break;
}
case REMOTE_IR_CMD_DECREMENT_HOUR: // decrement hour
{
if (hour > 0)
{
hour--;
}
else
{
hour = 23;
}
second = 0;
display_flag = DISPLAY_FLAG_UPDATE_ALL;
time_changed = 1;
break;
}
case REMOTE_IR_CMD_INCREMENT_HOUR: // increment hour
{
if (hour < 23)
{
hour++;
}
else
{
hour = 0;
}
second = 0;
display_flag = DISPLAY_FLAG_UPDATE_ALL;
time_changed = 1;
break;
}
case REMOTE_IR_CMD_DECREMENT_MINUTE: // decrement minute
{
if (minute > 0)
{
minute--;
}
else
{
minute = 59;
}
second = 0;
display_flag = DISPLAY_FLAG_UPDATE_ALL;
time_changed = 1;
break;
}
case REMOTE_IR_CMD_INCREMENT_MINUTE: // increment minute
{
if (minute < 59)
{
minute++;
}
else
{
minute = 0;
}
second = 0;
display_flag = DISPLAY_FLAG_UPDATE_ALL;
time_changed = 1;
break;
}
case REMOTE_IR_CMD_DECREMENT_BRIGHTNESS_RED: // decrement red brightness
{
display_decrement_color_red ();
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_INCREMENT_BRIGHTNESS_RED: // increment red brightness
{
display_increment_color_red ();
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_DECREMENT_BRIGHTNESS_GREEN: // decrement green brightness
{
display_decrement_color_green ();
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_INCREMENT_BRIGHTNESS_GREEN: // increment green brightness
{
display_increment_color_green ();
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_DECREMENT_BRIGHTNESS_BLUE: // decrement blue brightness
{
display_decrement_color_blue ();
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_INCREMENT_BRIGHTNESS_BLUE: // increment blue brightness
{
display_increment_color_blue ();
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_AUTO_BRIGHTNESS_CONTROL: // toggle auto brightness
{
auto_brightness = ! auto_brightness;
last_ldr_value = 0xFF;
display_set_automatic_brightness_control (auto_brightness);
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_DECREMENT_BRIGHTNESS: // decrement brightness
{
if (auto_brightness)
{
auto_brightness = 0;
last_ldr_value = 0xFF;
display_set_automatic_brightness_control (auto_brightness);
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
}
display_decrement_brightness ();
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_INCREMENT_BRIGHTNESS: // increment brightness
{
if (auto_brightness)
{
auto_brightness = 0;
last_ldr_value = 0xFF;
display_set_automatic_brightness_control (auto_brightness);
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
}
display_increment_brightness ();
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_GET_TEMPERATURE: // get temperature
{
show_temperature = 1;
break;
}
default:
{
break;
}
}
#endif // SAVE_RAM == 0
if (time_changed)
{
if (rtc_is_up)
{
tm.tm_hour = hour;
tm.tm_min = minute;
tm.tm_sec = second;
rtc_set_date_time (&tm);
}
time_changed = 0;
}
}
return 0;
}
