U16 temp_read(U8 num)
{
U8 i;
U8 low,high;
U16 t;
float tt;
temp_init();
temp_writeonechar(0x55);
for(i=0;i<8;i++)
temp_writeonechar(rom[num][i]);
temp_writeonechar(0x44);
temp_init();
temp_writeonechar(0x55);
for(i=0;i<8;i++)
temp_writeonechar(rom[num][i]);
temp_writeonechar(0xbe);
low=temp_readonechar();
high=temp_readonechar();
t=high;
t<<=8;
t|=low;
tt=t*0.0625;
t=tt*10+0.5;
return t;
}
/**
* \brief This is main...
*/
int
main(void)
{
lcd_init();
key_init();
uart_init();
eeprom_init();
temp_init();
timer_init();
sei();
lcd_symbol_set(LCD_SYMBOL_RAVEN);
//lcd_symbol_set(LCD_SYMBOL_IP);
timer_start();
for (;;){
/* Make sure interrupts are always on */
sei();
/* Process any progress frames */
uart_serial_rcv_frame(false);
} /* end for(). */
} /* end main(). */
void init(void) {
// set up watchdog
wd_init();
// set up serial
serial_init();
// set up inputs and outputs
io_init();
// set up timers
timer_init();
// read PID settings from EEPROM
heater_init();
// set up default feedrate
current_position.F = startpoint.F = next_target.target.F = SEARCH_FEEDRATE_Z;
// start up analog read interrupt loop, if anything uses analog as determined by ANALOG_MASK in your config.h
analog_init();
// set up temperature inputs
temp_init();
// enable interrupts
sei();
// reset watchdog
wd_reset();
// say hi to host
serial_writestr_P(PSTR("Start\nok\n"));
}
void temp_rom()
{
U8 i;
puts("ROM:");
temp_init();
temp_writeonechar(0x33);
for(i=0;i<8;i++)
printf(" 0x%hhx ",temp_readonechar());
}
U16 temp_read__()
{
U8 low,high;
U16 t;
float tt;
temp_init();
temp_writeonechar(0xcc);
temp_writeonechar(0x44);
temp_init();
temp_writeonechar(0xcc);
temp_writeonechar(0xbe);
low=temp_readonechar();
high=temp_readonechar();
t=high;
t<<=8;
t|=low;
tt=t*0.0625;
t=tt*10+0.5;
return t;
}
/// Startup code, run when we come out of reset
void init(void) {
halInit();
chSysInit();
#if defined(PORT_LED1) && defined(PIN_LED1)
palSetPadMode(PORT_LED1, PIN_LED1, PAL_MODE_OUTPUT_PUSHPULL);
#endif
#if defined(PORT_LED2) && defined(PIN_LED2)
palSetPadMode(PORT_LED2, PIN_LED2, PAL_MODE_OUTPUT_PUSHPULL);
#endif
// set up watchdog
wd_init();
// set up serial
serial_init();
// set up G-code parsing
gcode_init();
// set up inputs and outputs
io_init();
// set up timers
timer_init();
// read PID settings from EEPROM
heater_init();
// set up dda
dda_init();
// start up analog read interrupt loop,
// if any of the temp sensors in your config.h use analog interface
analog_init();
// set up temperature inputs
temp_init();
// enable interrupts
enable_irq();
// reset watchdog
wd_reset();
// say hi to host
serial_writestr_P(PSTR("start\nok\n"));
}
/**
* \brief This will enable or disable the JTAG debug interface to allow for
* proper temperature sensor readings.
*
* \param val Flag to trigger the proper debug mode.
*/
void
menu_debug_mode(uint8_t *val)
{
if(val){
jtd_set(true);
temp_init();
/* Store setting in EEPROM. */
eeprom_write_byte(EEPROM_DEBUG_ADDR, 0xFF);
}
else{
jtd_set(false);
/* Store setting in EEPROM. */
eeprom_write_byte(EEPROM_DEBUG_ADDR, 0x01);
}
//SREG = sreg;
}
/// Startup code, run when we come out of reset
void init(void) {
// set up watchdog
wd_init();
// set up serial
serial_init();
// set up G-code parsing
gcode_init();
// set up inputs and outputs
io_init();
// set up timers
timer_init();
// read PID settings from EEPROM
heater_init();
// set up dda
dda_init();
// start up analog read interrupt loop,
// if any of the temp sensors in your config.h use analog interface
analog_init();
// set up temperature inputs
temp_init();
// enable interrupts
sei();
// reset watchdog
wd_reset();
// prepare the power supply
power_init();
// say hi to host
serial_writestr_P(PSTR("start\nok\n"));
}
/** \brief Read current temperature's raw value
* \return EOF on error
*/
int16_t
sensor_temp_get_raw()
{
int16_t result;
if (!temp_initialized) {
temp_init();
}
/* Power up sensor */
TEMP_PORT |= (1 << TEMP_BIT);
/* Init ADC and measure */
adc_init(ADC_CHAN_ADC4, ADC_TRIG_FREE_RUN, ADC_REF_AVCC, ADC_PS_128);
adc_conversion_start();
while ((result = adc_result_get(ADC_ADJ_RIGHT)) == EOF ){
;
}
adc_deinit();
/* Power down sensor */
TEMP_PORT &= ~(1 << TEMP_BIT);
return result;
}
int main(void)
{
sys_init();
leds_init();
stepper_init();
// inputs_init();
usb_init();
gcode_init();
temp_init();
while (1)
{
// should go idle...
Delay(10);
char buffer[255];
gets(buffer);
if (buffer[0] != '\0')
{
gcode_parse(buffer);
}
}
}
int unicorn_init(void)
{
channel_tag fan = NULL;
int ret = 0;
board_info_t board_info;
printf("unicorn_init...\n");
ret = eeprom_read_board_info(EEPROM_DEV, &board_info);
if (ret < 0) {
printf("Read eeprom board info failed\n");
return -1;
}
if (!strncasecmp("bbp1s", board_info.name, 5)) {
bbp_board_type = BOARD_BBP1S;
} else if(!strncasecmp("bbp1", board_info.name, 4)){
bbp_board_type = BOARD_BBP1;
}
printf("board name:%s, version:%s, get board type:%d \n", board_info.name, board_info.version, bbp_board_type);
/*
* Create fifo
* fifo_plan2st, fifo_st2plan
* fifo_plan2gc, fifo_gc2plan
*/
Fifo_Attrs fAttrs = Fifo_Attrs_DEFAULT;
hFifo_plan2st = Fifo_create(&fAttrs);
hFifo_st2plan = Fifo_create(&fAttrs);
if ((hFifo_st2plan == NULL) ||
(hFifo_plan2st == NULL)) {
printf("Create Fifo failed\n");
return -1;
}
Pause_Attrs pAttrs = Pause_Attrs_DEFAULT;
hPause_printing = Pause_create(&pAttrs);
if (hPause_printing == NULL) {
printf("Create pause err\n");
return -1;
} else {
Pause_on(hPause_printing);
}
/* set up unicorn system */
ret = unicorn_setup();
if (ret < 0) {
return ret;
}
/* init sub systems of unicorn */
ret = parameter_init(EEPROM_DEV);
if (ret < 0) {
printf("parameter_init failed\n");
return ret;
}
ret = analog_init();
if (ret < 0) {
printf("analog_init failed\n");
return ret;
}
ret = temp_init();
if (ret < 0) {
printf("temp_init failed\n");
return ret;
}
ret = pwm_init();
if (ret < 0) {
printf("pwm_init failed\n");
return ret;
}
ret = fan_init();
if (ret < 0) {
printf("fan_init failed\n");
return ret;
}
ret = heater_init();
if (ret < 0) {
printf("heater_init failed\n");
return ret;
}
#ifdef SERVO
if (bbp_board_type == BOARD_BBP1S) {
ret = servo_init();
if (ret < 0) {
printf("servo_init failed\n");
return ret;
}
}
#endif
ret = lmsw_init();
if (ret < 0) {
printf("lmsw_init failed\n");
return ret;
}
ret = plan_init();
if (ret < 0) {
printf("plan_init failed\n");
return ret;
}
ret = stepper_init();
if (ret < 0) {
printf("stepper_init failed\n");
return ret;
}
ret = gcode_init();
if (ret < 0) {
printf("gcode_init failed\n");
return ret;
}
fan = fan_lookup_by_name("fan_3");
if (fan) {
fan_set_level(fan, DEFAULT_FAN_MAX_LEVEL);
fan_enable(fan);
}
fan = fan_lookup_by_name("fan_4");
if (fan) {
fan_enable(fan);
fan_set_level(fan, DEFAULT_FAN_MAX_LEVEL);
}
fan = fan_lookup_by_name("fan_5");
if (fan) {
fan_enable(fan);
fan_set_level(fan, DEFAULT_FAN_MAX_LEVEL);
}
fan = fan_lookup_by_name("fan_6");
if (fan) {
fan_enable(fan);
fan_set_level(fan, DEFAULT_FAN_MAX_LEVEL);
}
printf("unicorn_init ok!!!\n");
return ret;
}
/*
* Main program loop
*
*/
int main (void)
{
char cCommand[64];
char cCommand_last[64];
memset(&cCommand, 0, sizeof(cCommand));
memset(&cCommand_last, 0, sizeof(cCommand_last));
cCommand[0] = '\0';
charcount = 0;
struct ip_addr x_ip_addr, x_net_mask, x_gateway;
sysclk_init();
board_init();
// Set up the GPIO pin for the Mater Select jumper
ioport_init();
ioport_set_pin_dir(MASTER_SEL, IOPORT_DIR_INPUT);
masterselect = ioport_get_pin_level(MASTER_SEL); // true = slave
stacking_init(masterselect); // Initialise the stacking connector as either master or slave
// Set the IRQ line as either master or slave
if(masterselect) {
ioport_set_pin_dir(SPI_IRQ1, IOPORT_DIR_OUTPUT);
} else {
ioport_set_pin_dir(SPI_IRQ1, IOPORT_DIR_INPUT);
}
irq_initialize_vectors(); // Initialize interrupt vector table support.
cpu_irq_enable(); // Enable interrupts
stdio_usb_init();
spi_init();
eeprom_init();
temp_init();
membag_init();
loadConfig(); // Load Config
IP4_ADDR(&x_ip_addr, Zodiac_Config.IP_address[0], Zodiac_Config.IP_address[1],Zodiac_Config.IP_address[2], Zodiac_Config.IP_address[3]);
IP4_ADDR(&x_net_mask, Zodiac_Config.netmask[0], Zodiac_Config.netmask[1],Zodiac_Config.netmask[2], Zodiac_Config.netmask[3]);
IP4_ADDR(&x_gateway, Zodiac_Config.gateway_address[0], Zodiac_Config.gateway_address[1],Zodiac_Config.gateway_address[2], Zodiac_Config.gateway_address[3]);
switch_init();
/* Initialize lwIP. */
lwip_init();
/* Add data to netif */
netif_add(&gs_net_if, &x_ip_addr, &x_net_mask, &x_gateway, NULL, ethernetif_init, ethernet_input);
/* Make it the default interface */
netif_set_default(&gs_net_if);
netif_set_up(&gs_net_if);
// Telnet to be included in v0.63
//telnet_init();
/* Initialize timer. */
sys_init_timing();
int v,p;
// Create port map
for (v = 0;v < MAX_VLANS;v++)
{
if (Zodiac_Config.vlan_list[v].uActive == 1 && Zodiac_Config.vlan_list[v].uVlanType == 1)
{
for(p=0;p<4;p++)
{
if (Zodiac_Config.vlan_list[v].portmap[p] == 1) Zodiac_Config.of_port[p] = 1; // Port is assigned to an OpenFlow VLAN
}
}
if (Zodiac_Config.vlan_list[v].uActive == 1 && Zodiac_Config.vlan_list[v].uVlanType == 2)
{
for(p=0;p<4;p++)
{
if (Zodiac_Config.vlan_list[v].portmap[p] == 1)
{
Zodiac_Config.of_port[p] = 0; // Port is assigned to a Native VLAN
NativePortMatrix += 1<<p;
}
}
}
}
while(1)
{
task_switch(&gs_net_if);
task_command(cCommand, cCommand_last);
// Only run the following tasks if set to Master
if(masterselect == false)
{
sys_check_timeouts();
task_openflow();
}
}
}
int main(int argc, char **argv)
{
//#setup#
//data_collector is responsible for processing
//any files specified in the user-specified options.
set_error_file(stderr);
int temp_status = temp_init();
if(temp_status != 0)
{
die("error %d: temperature sensor initialization",
temp_status);
}
if(INTERVAL < MIN_INTERVAL)
{
die("error: INTERVAL %d is less than %d\n",
(int)INTERVAL, (int)MIN_INTERVAL);
}
// sigemptyset(&mask_chld);
// sigaddset(&mask_chld, SIGCHLD);
//if(signal(SIGCHLD, child_terminated) == SIG_ERR)
//{
// die("setting SIGCHLD handler failed\n");
//}
options_populate(argc, argv);
//Determine the proper error file ASAP.
//Otherwise keep the default, stderr, set above.
if(options_opt.error_file != NULL)
{
if(!options_opt.append_error &&
(access(options_opt.output_file, F_OK) != -1))
{
die("Error file %s already exists and -a not specified\n",
options_opt.error_file);
}
//Open in append mode. If the file doesn't exist,
//it will be created.
set_error_file(fopen(options_opt.error_file, "a"));
}
timeout_ms = options_opt.timeout_sec*1000;
//##open file##
//If an output file is unspecified by the user, output
//to stdout.
if(options_opt.output_file != NULL)
{
if(access(options_opt.output_file, F_OK) != -1)
{
die("File %s already exists\n", options_opt.output_file);
}
output_file_handle = fopen(options_opt.output_file, "w");
}
else
{
output_file_handle = stdout;
}
start_power();
#ifdef COLLECT_PWS
init_pws();
start_pws();
#endif
//signal typically returns a pointer to the previous
//signal handler, but can also error
//if(signal(SIGALRM, collect) == SIG_ERR)
//{
// fprintf(stderr, "error: could not set SIGALRM signal handler\n");
// exit(1);
//}
//#debug#
collect_data();
//#loop#
// alarm(INTERVAL);
// pause();
//#cleanup#
fclose(output_file_handle);
temp_cleanup();
power_cleanup();
delete_options();
#ifdef COLLECT_PWS
pws_cleanup();
#endif
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
* 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;
}
/**
* \brief This is main...
*/
int
main(void)
{
lcd_init();
key_init();
uart_init();
eeprom_init();
temp_init();
timer_init();
sei();
lcd_symbol_set(LCD_SYMBOL_RAVEN);
lcd_symbol_set(LCD_SYMBOL_IP);
/* Start with main menu */
read_menu(0);
/* and draw it */
lcd_puts_P(menu.text);
timer_start();
for (;;){
/* Make sure interrupts are always on */
sei();
/* The one second timer has fired. */
if(timer_flag){
timer_flag = false;
/* Check if main menu needs toggled. */
check_main_menu();
/* Update LCD with temp data. */
if(temp_flag){
menu_display_temp();
}
/* Auto send temp data to 1284p. */
if(auto_temp){
menu_send_temp();
}
/* If ping mode, send 4 ping requests and then stop. */
if(ping_mode){
if((PING_ATTEMPTS == count) && !timeout_flag){
count = 0;
timeout_count = 0;
menu_stop_ping();
}
else if(timeout_flag){
timeout_flag = false;
timeout_count++;
/* Display timeout message if all PING_ATTEMPTS were not successful. */
if(PING_ATTEMPTS == timeout_count){
lcd_puts_P(PSTR("PINGS FAILED"));
}
}
else{
count = menu_send_ping();
}
}
}
/* Check for button press and deal with it */
if (is_button()){
/* Dispatch the button pressed */
switch (get_button()){
case KEY_UP:
read_menu(menu.up);
lcd_puts_P(menu.text);
break;
case KEY_DOWN:
read_menu(menu.down);
lcd_puts_P(menu.text);
break;
case KEY_LEFT:
read_menu(menu.left);
lcd_puts_P(menu.text);
break;
case KEY_RIGHT:
/*
* Check to see if we should show another menu or
* run a function
*/
if (!menu.enter_func){
/* Just another menu to display */
read_menu(menu.right);
lcd_puts_P(menu.text);
break;
}
/* Drop through here */
case KEY_ENTER:
/* Call the menu function on right or enter buttons */
if (menu.enter_func){
menu.enter_func(menu.state);
if (menu.state){
/*
* We just called a selection menu (not a test),
* so re-display the text for this menu level
*/
lcd_puts_P(menu.text);
}
/* After enter key, check the right button menu and display. */
read_menu(menu.right);
lcd_puts_P(menu.text);
}
break;
default:
break;
}
/* After button press, check for menus... */
check_menu();
}
/* Process any progress frames */
uart_serial_rcv_frame(false);
} /* end for(). */
} /* end main(). */