void network_init()
{
#ifdef USE_esp8266
esp8266_init();
web_server_init();
#endif
}
kaa_error_t kaa_client_state_process(kaa_client_t *kaa_client)
{
KAA_RETURN_IF_NIL(kaa_client, KAA_ERR_BADPARAM);
kaa_error_t error_code = KAA_ERR_NONE;
esp8266_error_t esp8266_error;
switch (kaa_client->connection_state) {
case KAA_CLIENT_ESP8266_STATE_UNINITED:
esp8266_error = esp8266_init(kaa_client->controler);
if (esp8266_error == ESP8266_ERR_NONE) {
kaa_client->connection_state = KAA_CLIENT_ESP8266_STATE_INIT_OK;
KAA_LOG_INFO(kaa_client->kaa_context->logger, KAA_ERR_NONE, "ESP8266 initialized successfully");
} else {
KAA_LOG_ERROR(kaa_client->kaa_context->logger, KAA_ERR_NONE, "ESP8266 initialization failed: %d", esp8266_error);
esp8266_reset();
}
break;
case KAA_CLIENT_ESP8266_STATE_INIT_OK:
ledOn();
esp8266_error = esp8266_connect_wifi(kaa_client->controler,
kaa_client->wifi_ssid, kaa_client->wifi_pswd);
if (esp8266_error == ESP8266_ERR_NONE) {
kaa_client->connection_state = KAA_CLIENT_WIFI_STATE_CONNECTED;
KAA_LOG_INFO(kaa_client->kaa_context->logger, KAA_ERR_NONE, "ESP8266 WiFi to %s network connected",
kaa_client->wifi_ssid);
} else {
KAA_LOG_ERROR(kaa_client->kaa_context->logger, KAA_ERR_NONE, "ESP8266 connect to WiFi %s failed: %d",
kaa_client->wifi_ssid, esp8266_error);
kaa_client->connection_state = KAA_CLIENT_WIFI_STATE_UNCONNECTED;
}
ledOff();
break;
case KAA_CLIENT_WIFI_STATE_CONNECTED:
break;
default:
kaa_client->connection_state = KAA_CLIENT_ESP8266_STATE_UNINITED;
break;
}
return error_code;
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
* 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;
}
/*! Initialization task
This task initializes all other tasks
\param[in] inParameters Unused
*/
static void init_task(void * inParameters) {
TaskHandle_t xHandle = NULL;
{ /* measure 100 percent idle */
uint32_t lBackupCounter;
lBackupCounter = sLoadCounter;
vTaskDelay(1000);
s100percentIdle = sLoadCounter - lBackupCounter;
}
/* init ws2812 library */
ws2812_init();
/* init animation */
ws2812_animation_init();
if(!xTaskCreate(cpu_load_task, ( const char * )"cpu", configMINIMAL_STACK_SIZE, NULL, CPU_LOAD_TASK_PRIORITY, &xHandle)) {
/* check how we can handle errors */
}
/* start led task */
if(!xTaskCreate(ws2812_anim_task, "ws2812_anim", configMINIMAL_STACK_SIZE * 8, NULL, LED_TASK_PRIORITY, &xHandle)) {
/* check how we can handle errors */
}
/* init esp8266 library */
esp8266_init();
/* start socket task */
if(!xTaskCreate(esp8266_socket_task, "esp8266_so", configMINIMAL_STACK_SIZE, NULL, ESP8266_SOCKET_TASK_PRIORITY, &xHandle)) {
/* check how we can handle errors */
}
if(!xTaskCreate(esp8266_wifi_task, "esp8266_wi", configMINIMAL_STACK_SIZE * 2, NULL, ESP8266_WIFI_TASK_PRIORITY, &xHandle)) {
/* check how we can handle errors */
}
/* start rx task */
if(!xTaskCreate(esp8266_rx_task, "esp8266_rx", configMINIMAL_STACK_SIZE * 6, NULL, ESP8266_RX_TASK_PRIORITY, &xHandle)) {
/* check how we can handle errors */
}
/* configure the esp8266 module */
esp8266_configure();
/* initialize web server user data */
if(!main_web_content_init()) {
/* check how we can handle errors */
}
/* start web server */
esp8266_http_server_start(ESP8266_HTTP_SERVER_PRIORITY);
/* start mqtt client task */
// if(!xTaskCreate(esp8266_mqtt_task, ( const char * )"esp8266_mqtt", configMINIMAL_STACK_SIZE * 32, NULL, ESP8266_MQTT_TASK_PRIORITY, &xHandle)) {
/* check how we can handle errors */
// }
/* delete this task */
vTaskDelete(NULL);
}
int main(void)
{
char *text = "abc123456879754461325456478974564153217897654564132156489768545613214567489465413521231324567489797468545646958798";
int payload_length, context_length;
bool esp8266_exist=false, connected=false, test_send=true;
uint8_t *context;
test[0] = 0x81;
test[1] = strlen(text);
strcpy( (char *)test+2, text );
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 168 MHz */
SystemClock_Config();
/*##-1- Configure the UART peripheral ######################################*/
/* Put the USART peripheral in the Asynchronous mode (UART Mode) */
/* UART1 configured as follow:
- Word Length = 8 Bits
- Stop Bit = One Stop bit
- Parity = None
- BaudRate = 9600 baud
- Hardware flow control disabled (RTS and CTS signals) */
UartHandle.Instance = USARTx;
UartHandle.Init.BaudRate = 115200;
UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
UartHandle.Init.StopBits = UART_STOPBITS_1;
UartHandle.Init.Parity = UART_PARITY_NONE;
UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
UartHandle.Init.Mode = UART_MODE_TX_RX;
UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
if(HAL_UART_Init(&UartHandle) != HAL_OK)
{
Error_Handler();
}
/* The board receives the message and sends it back */
/*##-2- Put UART peripheral in reception process ###########################*/
if(HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)aRxBuffer8266, RXBUFFERSIZE) != HAL_OK)
{
while(1);
}
if( esp8266_init() ){
esp8266_exist = true;
if( !esp8266_cmd("AT+CWMODE=2\r\n", "no change\r\n", 100) && !esp8266_cmd("AT+CWMODE=2\r\n", "\r\nOK\r\n", 100) ){
while(1);
}
if( !esp8266_cmd("AT+CIPMUX=1\r\n", "\r\nOK\r\n", 100) ){
while(1);
}
if( !esp8266_cmd("AT+CIPSERVER=1,8080\r\n", "\r\nOK\r\n", 200) ){
while(1);
}
}
while (1){
switch( esp8266_parse(payload, &payload_length) ){ //maybe more than one event in the messages, but parse only one each time
case NO_EVENT :
break;
case LINK :
break;
case UNLINK :
connected = 0;
break;
case PAYLOAD :
if( 0 == strncmp((const char *)payload, "GET /chat", 9) ){ //handshake
web_soket_handshake( (char *)payload );
}else if( 0x81 == *payload ){ //websocket data
rm_mask(payload, payload_length, &context, &context_length);
if( 0 == strncmp( (char *)context, "login:"******"fanlong: stop", 13 ) ){
test_send = false;
}else if( 0 == strncmp( (char *)context, "fanlong: start", 14 ) ){
test_send = true;
}
}
break;
case SEND_OK :
break;
case RST :
break;
default :
break;
}
/* at least one char will be received in 1 ms;
if you ignore this delay, maybe you update_length() just after one message ended and the next is coming.
coment it if and only if you are sure there is no message just begin;
*/
HAL_Delay(1);
if( update_length() ){
continue;// still have message
}
//now I'm sure there is no more message will come
if( connected && test_send ){ //make sure rxbuffer is empty
esp8266_send(0, test, strlen(text)+2);
HAL_Delay(100);
}
}
}
/*****************************************
* MAIN
*****************************************/
int main(void)
{
SystemInit();
UB_Systick_Init();
// Init of UB libs
UB_TIMER2_Init_FRQ( 100 );
UB_TIMER5_Init_FRQ( 10000 );
UB_Led_Init();
UB_DigIn_Init();
UB_DigOut_Init();
UB_ADC1_SINGLE_Init();
UB_RTC_Init();
UB_RTC_SetWakeUpInterrupt(RTC_WAKEUP_5s);
// Note: code needs to be reconfigured for Nucleo Board (Frequency of 96 MHz should also be checked)
UB_WS2812_Init();
WC_DisableAllElements();
WC_SetColor( WS2812_HSV_COL_WHITE );
WC_SetBrightness( 10 );
WC_SetElement(WC_ELEMENT_ES, 1);
WC_Refresh();
UB_Uart_Init();
esp8266_init();
UB_Systick_Pause_ms(1000);
// Indicate successful booting
UB_Led_On( LED_GREEN );
UB_Systick_Pause_s(1);
UB_Led_Off( LED_GREEN );
// Start timers and therefore cyclic actions in the call backs below
UB_TIMER2_Start();
UB_TIMER5_Start();
UB_DigOut_Lo(DOUT_PB7); // Set ground for LDR
UB_DigOut_Lo(DOUT_PB9); // Set PC9 low to start DCF module
while(1) {
// Handle word matrix refreshes
if ( gWcIsToBeRefreshed == Bit_SET ){
WC_Refresh();
gWcIsToBeRefreshed = Bit_RESET;
}
// Check if update of time is necessary
#ifndef DISABLE_DCF
if ( DcfTimeWasSetRecently() == Bit_RESET )
gDcfRxInProgress = Bit_SET;
#endif
// Handle IR remote
if ( irmp_get_data( &irData ) )
ProcessIrDataPacket( irData );
// Read Ambient brightness and set LED brightness
if ( gDcfRxInProgress == Bit_RESET ){
ambientBrightnessCurrent = SlidingAverageOnLastValues( UB_ADC1_SINGLE_Read( ADC_PA1 ) );
int brightnessToSet = 100.0 * GetBrightnessFactor( ambientBrightnessPoints, ambientBrightnessLedDimmingFactors, ambientBrightnessCurrent );
if ( brightnessToSet < LED_BRIGHTNESS_OFF_THRESHOLD )
WC_SetColor( WS2812_HSV_COL_OFF );
else
WC_SetBrightness( brightnessToSet );
gWcIsToBeRefreshed = Bit_SET;
}
// Handle ESP8266 receive
esp8266_handle_receive();
if( esp8266_request_time_from_google() == 1 ) {
UB_RTC = Esp8266_curTime;
UB_RTC_SetClock( RTC_DEC );
SetWordMatrix( UB_RTC_GetClock(RTC_DEC) );
gWcIsToBeRefreshed = Bit_SET;
}
}
}
