void display_boot_info(void)
{
char bl1_version[9] = {0};
printf(" \n");
display_banner();
print_cpuinfo();
// Display dram info
display_dram_config();
// Display BL1 version
#ifdef CONFIG_TRUSTZONE
printf("BL1 version: N/A (TrustZone Enabled BSP)\n");
#else
strncpy(&bl1_version[0], (char *)0x02022fc8, 8);
printf("BL1 version: %s\n", &bl1_version[0]);
#endif
// Display boot mode
printf("\n\nChecking Boot Mode ...");
if(OmPin == BOOT_ONENAND) {
printf(" OneNand\n");
} else if (OmPin == BOOT_NAND) {
printf(" NAND\n");
} else if (OmPin == BOOT_MMCSD) {
printf(" SDMMC\n");
} else if (OmPin == BOOT_EMMC) {
printf(" EMMC4.3\n");
} else if (OmPin == BOOT_EMMC_4_4) {
printf(" EMMC4.41\n");
}
printf("\n");
}
/* Display program usage information */
void display_usage() {
display_banner();
printf("Usage: %s [ -dFhpqs ] [-b file ] [ -f format ] [ -i device ] [ -l threshold ]\n"
" [ -m methods ] [ -n count ] [ -o file ] [ -P file ] [ -r file ]\n"
" [ -t seconds] [ -u user ] [ 'expression' ]\n\n", PROG_NAME);
printf(" -b file write HTTP packets to a binary dump file\n"
" -d run as daemon\n"
" -f format specify output format string\n"
" -F force output flush\n"
" -h print this help information\n"
" -i device listen on this interface\n"
" -l threshold specify a rps threshold for rate statistics\n"
" -m methods specify request methods to parse\n"
" -n count set number of HTTP packets to parse\n"
" -o file write output to a file\n"
" -p disable promiscuous mode\n"
" -P file use custom PID filename when running in daemon mode \n"
" -q suppress non-critical output\n"
" -r file read packets from input file\n"
" -s run in HTTP requests per second mode\n"
" -t seconds specify the display interval for rate statistics\n"
" -u user set process owner\n"
" expression specify a bpf-style capture filter\n\n");
printf("Additional information can be found at:\n"
" http://dumpsterventures.com/jason/httpry\n\n");
exit(EXIT_SUCCESS);
}
/* Display program usage information */
void display_usage() {
display_banner();
printf("Usage: %s [ -dhpq ] [-b file ] [ -f format ] [ -i device ] [ -m methods ]\n"
" [ -n count ] [ -r file ] [ -o file ] [ -u user ] [ 'expression' ]\n\n", PROG_NAME);
printf(" -b file write HTTP packets to a binary dump file\n"
" -d run as daemon\n"
" -f format specify output format string\n"
" -h print this help information\n"
" -i device listen on this interface\n"
" -m methods specify request methods to parse\n"
" -n count set number of HTTP packets to parse\n"
" -o file write output to a file\n"
" -p disable promiscuous mode\n"
" -q suppress non-critical output\n"
" -r file read packets from input file\n"
" -u user set process owner\n"
" expression specify a bpf-style capture filter\n\n");
printf("Additional information can be found at:\n"
" http://dumpsterventures.com/jason/httpry\n\n");
exit(EXIT_SUCCESS);
}
void early_console_start(const char *name, int baudrate)
{
void *base = get_early_console_base(name);
if (base) {
early_console_init(base, baudrate);
INITDATA(initialized) = CONSOLE_INIT_EARLY;
INITDATA(early_console_base) = base;
display_banner();
}
}
int console_register(struct console_device *newcdev)
{
struct device_d *dev = &newcdev->class_dev;
int first = 0;
char ch;
strcpy(dev->name, "cs");
dev->type_data = newcdev;
register_device(dev);
if (newcdev->setbrg) {
newcdev->baudrate_param.set = console_baudrate_set;
newcdev->baudrate_param.name = "baudrate";
sprintf(newcdev->baudrate_string, "%d",
CONFIG_BAUDRATE);
console_baudrate_set(dev, &newcdev->baudrate_param,
newcdev->baudrate_string);
newcdev->baudrate_param.value = newcdev->baudrate_string;
dev_add_param(dev, &newcdev->baudrate_param);
}
newcdev->active_param.set = console_std_set;
newcdev->active_param.name = "active";
newcdev->active_param.value = newcdev->active;
dev_add_param(dev, &newcdev->active_param);
initialized = CONSOLE_INIT_FULL;
#ifdef CONFIG_CONSOLE_ACTIVATE_ALL
console_std_set(dev, &newcdev->active_param, "ioe");
#endif
#ifdef CONFIG_CONSOLE_ACTIVATE_FIRST
if (list_empty(&console_list)) {
first = 1;
console_std_set(dev, &newcdev->active_param, "ioe");
}
#endif
list_add_tail(&newcdev->list, &console_list);
if (console_output_buffer) {
while (kfifo_getc(console_output_buffer, &ch) == 0)
console_putc(CONSOLE_STDOUT, ch);
kfifo_free(console_output_buffer);
console_output_buffer = NULL;
}
#ifndef CONFIG_HAS_EARLY_INIT
if (first)
display_banner();
#endif
return 0;
}
int main(int argc, char **argv) {
int opt;
extern char *optarg;
extern int optind;
int loop_status;
signal(SIGHUP, &handle_signal);
signal(SIGINT, &handle_signal);
/* Process command line arguments */
while ((opt = getopt(argc, argv, "b:df:Fhpqi:l:m:n:o:P:r:st:u:S:")) != -1) {
switch (opt) {
case 'b': use_dumpfile = optarg; break;
case 'd': daemon_mode = 1; use_syslog = 1; break;
case 'f': format_str = optarg; break;
case 'F': force_flush = 1; break;
case 'h': display_usage(); break;
case 'i': interface = optarg; break;
case 'l': rate_threshold = atoi(optarg); break;
case 'm': methods_str = optarg; break;
case 'n': parse_count = atoi(optarg); break;
case 'o': use_outfile = optarg; break;
case 'p': set_promisc = 0; break;
case 'P': pid_filename = optarg; break;
case 'q': quiet_mode = 1; break;
case 'r': use_infile = optarg; break;
case 's': rate_stats = 1; break;
case 't': rate_interval = atoi(optarg); break;
case 'u': new_user = optarg; break;
case 'S': eth_skip_bits = atoi(optarg); break;
default: display_usage();
}
}
display_banner();
if (daemon_mode && !use_outfile)
LOG_DIE("Daemon mode requires an output file");
if (parse_count < 0)
LOG_DIE("Invalid -n value, must be 0 or greater");
if (rate_interval < 1)
LOG_DIE("Invalid -t value, must be 1 or greater");
if (rate_threshold < 1)
LOG_DIE("Invalid -l value, must be 1 or greater");
if (argv[optind] && *(argv[optind])) {
capfilter = argv[optind];
} else {
capfilter = default_capfilter;
}
if (!format_str) format_str = default_format;
if (rate_stats) format_str = rate_format;
parse_format_string(format_str);
if (!methods_str) methods_str = default_methods;
parse_methods_string(methods_str);
if (force_flush) {
if (setvbuf(stdout, NULL, _IONBF, 0) != 0)
LOG_WARN("Cannot disable buffering on stdout");
}
if (!pid_filename) pid_filename = PID_FILENAME;
pcap_hnd = prepare_capture(interface, set_promisc, use_infile, capfilter);
open_outfiles();
if (daemon_mode) runas_daemon();
if (new_user) change_user(new_user);
if ((buf = malloc(BUFSIZ + 1)) == NULL)
LOG_DIE("Cannot allocate memory for packet data buffer");
if (rate_stats)
init_rate_stats(rate_interval, use_infile, rate_threshold);
start_time = time(0);
loop_status = pcap_loop(pcap_hnd, -1, &parse_http_packet, NULL);
if (loop_status == -1) {
LOG_DIE("Problem reading packets from interface: %s", pcap_geterr(pcap_hnd));
} else if (loop_status == -2) {
PRINT("Loop halted, shutting down...");
}
print_stats();
cleanup();
return loop_status == -1 ? EXIT_FAILURE : EXIT_SUCCESS;
}
int main(int argc, char **argv) {
int opt;
extern char *optarg;
extern int optind;
int loop_status;
signal(SIGINT, &handle_signal);
/* Process command line arguments */
while ((opt = getopt(argc, argv, "b:df:hpqi:m:n:o:r:u:")) != -1) {
switch (opt) {
case 'b': use_dumpfile = optarg; break;
case 'd': daemon_mode = 1;
use_syslog = 1; break;
case 'f': format_str = optarg; break;
case 'h': display_usage(); break;
case 'i': interface = optarg; break;
case 'm': methods_str = optarg; break;
case 'n': parse_count = atoi(optarg); break;
case 'o': use_outfile = optarg; break;
case 'p': set_promisc = 0; break;
case 'q': quiet_mode = 1; break;
case 'r': use_infile = optarg; break;
case 'u': new_user = optarg; break;
default: display_usage();
}
}
display_banner();
if (daemon_mode && !use_outfile)
LOG_DIE("Daemon mode requires an output file");
if (parse_count < 0)
LOG_DIE("Invalid -n value, must be 0 or greater");
if (argv[optind] && *(argv[optind])) {
capfilter = argv[optind];
} else {
capfilter = default_capfilter;
}
if (!format_str) format_str = default_format;
parse_format_string(format_str);
if (!methods_str) methods_str = default_methods;
parse_methods_string(methods_str);
pcap_hnd = prepare_capture(interface, set_promisc, use_infile, capfilter);
open_outfiles();
if (daemon_mode) runas_daemon();
if (new_user) change_user(new_user);
if ((buf = malloc(BUFSIZ + 1)) == NULL)
LOG_DIE("Cannot allocate memory for packet data buffer");
start_time = time(0);
loop_status = pcap_loop(pcap_hnd, -1, &parse_http_packet, NULL);
if (loop_status == -1) {
LOG_DIE("Problem reading packets from interface: %s", pcap_geterr(pcap_hnd));
} else if (loop_status == -2) {
PRINT("Loop halted, shutting down...");
}
cleanup();
return loop_status == -1 ? EXIT_FAILURE : EXIT_SUCCESS;
}
void board_init_f(ulong board_type)
{
gd_t gd_data;
gd_t *new_gd;
bd_t *bd;
unsigned long *new_sp;
unsigned long monitor_len;
unsigned long monitor_addr;
unsigned long addr;
long sdram_size;
/* Initialize the global data pointer */
memset(&gd_data, 0, sizeof(gd_data));
gd = &gd_data;
/* Perform initialization sequence */
board_early_init_f();
cpu_init();
board_postclk_init();
env_init();
init_baudrate();
serial_init();
console_init_f();
display_banner();
sdram_size = initdram(board_type);
/* If we have no SDRAM, we can't go on */
if (sdram_size <= 0)
panic("No working SDRAM available\n");
/*
* Now that we have DRAM mapped and working, we can
* relocate the code and continue running from DRAM.
*
* Reserve memory at end of RAM for (top down in that order):
* - u-boot image
* - heap for malloc()
* - board info struct
* - global data struct
* - stack
*/
addr = CONFIG_SYS_SDRAM_BASE + sdram_size;
monitor_len = __bss_end__ - _text;
/*
* Reserve memory for u-boot code, data and bss.
* Round down to next 4 kB limit.
*/
addr -= monitor_len;
addr &= ~(4096UL - 1);
monitor_addr = addr;
/* Reserve memory for malloc() */
addr -= CONFIG_SYS_MALLOC_LEN;
#ifdef CONFIG_SYS_DMA_ALLOC_LEN
/* Reserve DMA memory (must be cache aligned) */
addr &= ~(CONFIG_SYS_DCACHE_LINESZ - 1);
addr -= CONFIG_SYS_DMA_ALLOC_LEN;
#endif
#ifdef CONFIG_LCD
#ifdef CONFIG_FB_ADDR
printf("LCD: Frame buffer allocated at preset 0x%08x\n",
CONFIG_FB_ADDR);
gd->fb_base = (void *)CONFIG_FB_ADDR;
#else
addr = lcd_setmem(addr);
printf("LCD: Frame buffer allocated at 0x%08lx\n", addr);
gd->fb_base = (void *)addr;
#endif /* CONFIG_FB_ADDR */
#endif /* CONFIG_LCD */
/* Allocate a Board Info struct on a word boundary */
addr -= sizeof(bd_t);
addr &= ~3UL;
gd->bd = bd = (bd_t *)addr;
/* Allocate a new global data copy on a 8-byte boundary. */
addr -= sizeof(gd_t);
addr &= ~7UL;
new_gd = (gd_t *)addr;
/* And finally, a new, bigger stack. */
new_sp = (unsigned long *)addr;
gd->stack_end = addr;
*(--new_sp) = 0;
*(--new_sp) = 0;
/*
* Initialize the board information struct with the
* information we have.
*/
bd->bi_dram[0].start = CONFIG_SYS_SDRAM_BASE;
bd->bi_dram[0].size = sdram_size;
bd->bi_baudrate = gd->baudrate;
memcpy(new_gd, gd, sizeof(gd_t));
relocate_code((unsigned long)new_sp, new_gd, monitor_addr);
}
int main(void)
{
struct image_info image;
char *media_str = NULL;
int ret;
char filename[FILENAME_BUF_LEN];
char of_filename[FILENAME_BUF_LEN];
memset(&image, 0, sizeof(image));
memset(filename, 0, FILENAME_BUF_LEN);
memset(of_filename, 0, FILENAME_BUF_LEN);
image.dest = (unsigned char *)JUMP_ADDR;
#ifdef CONFIG_OF_LIBFDT
image.of = 1;
image.of_dest = (unsigned char *)OF_ADDRESS;
#endif
#ifdef CONFIG_NANDFLASH
media_str = "NAND: ";
image.offset = IMG_ADDRESS;
image.length = IMG_SIZE;
#ifdef CONFIG_OF_LIBFDT
image.of_offset = OF_OFFSET;
image.of_length = OF_LENGTH;
#endif
#endif
#ifdef CONFIG_DATAFLASH
media_str = "SF: ";
image.offset = IMG_ADDRESS;
image.length = IMG_SIZE;
#ifdef CONFIG_OF_LIBFDT
image.of_offset = OF_OFFSET;
image.of_length = OF_LENGTH;
#endif
#endif
#ifdef CONFIG_SDCARD
media_str = "SD/MMC: ";
image.filename = filename;
strcpy(image.filename, OS_IMAGE_NAME);
#ifdef CONFIG_OF_LIBFDT
image.of_filename = of_filename;
strcpy(image.of_filename, OF_FILENAME);
#endif
#endif
#ifdef CONFIG_HW_INIT
hw_init();
#endif
display_banner();
#ifdef CONFIG_LOAD_ONE_WIRE
/* Load one wire informaion */
load_1wire_info();
#endif
init_loadfunction();
ret = (*load_image)(&image);
if (media_str)
dbgu_print(media_str);
if (ret == 0){
dbgu_print("Done to load image\n\r");
}
if (ret == -1) {
dbgu_print("Failed to load image\n\r");
while(1);
}
if (ret == -2) {
dbgu_print("Success to recovery\n\r");
while (1);
}
#ifdef CONFIG_SCLK
slowclk_switch_osc32();
#endif
return JUMP_ADDR;
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
* 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;
}
int main(void)
{
struct image_info image;
char *media_str = NULL;
int ret;
char filename[FILENAME_BUF_LEN];
char of_filename[FILENAME_BUF_LEN];
memset(&image, 0, sizeof(image));
memset(filename, 0, FILENAME_BUF_LEN);
memset(of_filename, 0, FILENAME_BUF_LEN);
image.dest = (unsigned char *)JUMP_ADDR;
#ifdef CONFIG_OF_LIBFDT
image.of = 1;
image.of_dest = (unsigned char *)OF_ADDRESS;
#endif
#ifdef CONFIG_FLASH
media_str = "FLASH: ";
image.offset = IMG_ADDRESS;
#if !defined(CONFIG_LOAD_LINUX) && !defined(CONFIG_LOAD_ANDROID)
image.length = IMG_SIZE;
#endif
#ifdef CONFIG_OF_LIBFDT
image.of_offset = OF_OFFSET;
#endif
#endif
#ifdef CONFIG_NANDFLASH
media_str = "NAND: ";
image.offset = IMG_ADDRESS;
#if !defined(CONFIG_LOAD_LINUX) && !defined(CONFIG_LOAD_ANDROID)
image.length = IMG_SIZE;
#endif
#ifdef CONFIG_OF_LIBFDT
image.of_offset = OF_OFFSET;
#endif
#endif
#ifdef CONFIG_DATAFLASH
media_str = "SF: ";
image.offset = IMG_ADDRESS;
#if !defined(CONFIG_LOAD_LINUX) && !defined(CONFIG_LOAD_ANDROID)
image.length = IMG_SIZE;
#endif
#ifdef CONFIG_OF_LIBFDT
image.of_offset = OF_OFFSET;
#endif
#endif
#ifdef CONFIG_SDCARD
media_str = "SD/MMC: ";
image.filename = filename;
strcpy(image.filename, IMAGE_NAME);
#ifdef CONFIG_OF_LIBFDT
image.of_filename = of_filename;
#endif
#endif
#ifdef CONFIG_HW_INIT
hw_init();
#endif
#if defined(CONFIG_SCLK)
#if !defined(CONFIG_SAMA5D4)
slowclk_enable_osc32();
#endif
#endif
#ifdef CONFIG_HW_DISPLAY_BANNER
display_banner();
#endif
#ifdef CONFIG_REDIRECT_ALL_INTS_AIC
redirect_interrupts_to_nsaic();
#endif
#ifdef CONFIG_LOAD_HW_INFO
/* Load board hw informaion */
load_board_hw_info();
#endif
#ifdef CONFIG_PM
at91_board_pm();
#endif
#ifdef CONFIG_DISABLE_ACT8865_I2C
act8865_workaround();
#endif
init_loadfunction();
#if defined(CONFIG_SECURE)
image.dest -= sizeof(at91_secure_header_t);
#endif
ret = (*load_image)(&image);
#if defined(CONFIG_SECURE)
if (!ret)
ret = secure_check(image.dest);
image.dest += sizeof(at91_secure_header_t);
#endif
if (media_str)
usart_puts(media_str);
if (ret == 0){
usart_puts("Done to load image\n");
}
if (ret == -1) {
usart_puts("Failed to load image\n");
while(1);
}
if (ret == -2) {
usart_puts("Success to recovery\n");
while (1);
}
#ifdef CONFIG_SCLK
slowclk_switch_osc32();
#endif
#if defined(CONFIG_ENTER_NWD)
switch_normal_world();
/* point never reached with TZ support */
#endif
return JUMP_ADDR;
}
int main(void)
{
struct image_info image;
char *media_str = NULL;
int ret;
char filename[FILENAME_BUF_LEN];
char of_filename[FILENAME_BUF_LEN];
memset(&image, 0, sizeof(image));
memset(filename, 0, FILENAME_BUF_LEN);
memset(of_filename, 0, FILENAME_BUF_LEN);
image.dest = (unsigned char *)JUMP_ADDR;
#ifdef CONFIG_OF_LIBFDT
image.of = 1;
image.of_dest = (unsigned char *)OF_ADDRESS;
#endif
#ifdef CONFIG_NANDFLASH
media_str = "NAND: ";
image.offset = IMG_ADDRESS;
#if !defined(CONFIG_LOAD_LINUX) && !defined(CONFIG_LOAD_ANDROID)
image.length = IMG_SIZE;
#endif
#ifdef CONFIG_OF_LIBFDT
image.of_offset = OF_OFFSET;
#endif
#endif
#ifdef CONFIG_DATAFLASH
media_str = "SF: ";
image.offset = IMG_ADDRESS;
#if !defined(CONFIG_LOAD_LINUX) && !defined(CONFIG_LOAD_ANDROID)
image.length = IMG_SIZE;
#endif
#ifdef CONFIG_OF_LIBFDT
image.of_offset = OF_OFFSET;
#endif
#endif
#ifdef CONFIG_SDCARD
media_str = "SD/MMC: ";
image.filename = filename;
strcpy(image.filename, IMAGE_NAME);
#ifdef CONFIG_OF_LIBFDT
image.of_filename = of_filename;
#endif
#endif
#ifdef CONFIG_HW_INIT
hw_init();
#endif
display_banner();
#ifdef CONFIG_LOAD_ONE_WIRE
/* Load one wire informaion */
load_1wire_info();
#endif
init_loadfunction();
ret = (*load_image)(&image);
if (media_str)
usart_puts(media_str);
if (ret == 0){
usart_puts("Done to load image\n");
}
if (ret == -1) {
usart_puts("Failed to load image\n");
while(1);
}
if (ret == -2) {
usart_puts("Success to recovery\n");
while (1);
}
#ifdef CONFIG_SCLK
slowclk_switch_osc32();
#endif
#if defined(CONFIG_ENTER_NWD)
switch_normal_world();
/* point never reached with TZ support */
#endif
return JUMP_ADDR;
}
