int application_start( void )
{
OSStatus err = kNoErr;
network_InitTypeDef_adv_st wNetConfigAdv={0};
MicoInit( );
/* Register user function when wlan connection status is changed */
err = mico_system_notify_register( mico_notify_WIFI_STATUS_CHANGED, (void *)micoNotify_WifiStatusHandler, NULL );
require_noerr( err, exit );
/* Register user function when wlan connection is faile in one attempt */
err = mico_system_notify_register( mico_notify_WIFI_CONNECT_FAILED, (void *)micoNotify_ConnectFailedHandler, NULL );
require_noerr( err, exit );
/* Initialize wlan parameters */
strcpy((char*)wNetConfigAdv.ap_info.ssid, "Xiaomi.Router"); /* wlan ssid string */
strcpy((char*)wNetConfigAdv.key, "stm32f215"); /* wlan key string or hex data in WEP mode */
wNetConfigAdv.key_len = strlen(ap_key); /* wlan key length */
wNetConfigAdv.ap_info.security = SECURITY_TYPE_AUTO; /* wlan security mode */
wNetConfigAdv.ap_info.channel = 0; /* Select channel automatically */
wNetConfigAdv.dhcpMode = DHCP_Client; /* Fetch Ip address from DHCP server */
wNetConfigAdv.wifi_retry_interval = 100; /* Retry interval after a failure connection */
/* Connect Now! */
wifi_station_log("connecting to %s...", wNetConfigAdv.ap_info.ssid);
micoWlanStartAdv(&wNetConfigAdv);
exit:
mico_rtos_delete_thread(NULL);
return err;
}
int application_start( void )
{
OSStatus err = kNoErr;
IPStatusTypedef para;
MicoInit( );
/*The notification message for the registered WiFi status change*/
err = MICOAddNotification( mico_notify_WIFI_STATUS_CHANGED, (void *)micoNotify_WifiStatusHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_WIFI_CONNECT_FAILED, (void *)micoNotify_ConnectFailedHandler );
require_noerr( err, exit );
err = mico_rtos_init_semaphore(&tcp_sem, 1);
require_noerr( err, exit );
connect_ap( );
mico_rtos_get_semaphore(&tcp_sem, MICO_WAIT_FOREVER);
micoWlanGetIPStatus(¶, Station);
tcp_server_log("tcp server ip: %s", para.ip);
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "TCP_server", tcp_server_thread, 0x800, NULL );
require_noerr_action( err, exit, tcp_server_log("ERROR: Unable to start the tcp server thread.") );
return err;
exit:
tcp_server_log("ERROR, err: %d", err);
return err;
}
int application_start( void )
{
MICOAddNotification( mico_notify_WIFI_STATUS_CHANGED, (void *)micoNotify_WifiStatusHandler );
network_InitTypeDef_adv_st wNetConfig;
#if MCU_POWERSAVE_ENABLED
MicoMcuPowerSaveConfig(true);
#endif
power_log( "Power measure program: RTOS and wlan initialized and connect wlan, wait station up to measure" );
MicoInit( );
#if IEEE_POWERSAVE_ENABLED
micoWlanEnablePowerSave();
#endif
memset(&wNetConfig, 0x0, sizeof(network_InitTypeDef_adv_st));
strncpy((char*)wNetConfig.ap_info.ssid, "William Xu", 32);
wNetConfig.ap_info.security = SECURITY_TYPE_AUTO;
strncpy((char*)wNetConfig.key, "mx099555", 64);
wNetConfig.key_len = 8;
wNetConfig.dhcpMode = true;
wNetConfig.wifi_retry_interval = 100;
micoWlanStartAdv(&wNetConfig);
power_log("connect to %s.....", wNetConfig.ap_info.ssid);
mico_rtos_delete_thread( NULL );
return 0;
}
int application_start( void )
{
//start
// lua_printf( "\r\n\r\nMiCO starting...(Free memory %d bytes)\r\n",MicoGetMemoryInfo()->free_memory);
MicoInit();
//watch dog
MicoWdgInitialize( DEFAULT_WATCHDOG_TIMEOUT);
mico_init_timer(&_watchdog_reload_timer,DEFAULT_WATCHDOG_TIMEOUT/2, _watchdog_reload_timer_handler, NULL);
mico_start_timer(&_watchdog_reload_timer);
//usrinterface
//MicoCliInit();
#if 1
// lua_printf("Free memory %d bytes\r\n", MicoGetMemoryInfo()->free_memory);
lua_rx_data = (uint8_t*)malloc(INBUF_SIZE);
ring_buffer_init ( (ring_buffer_t*)&lua_rx_buffer, (uint8_t*)lua_rx_data, INBUF_SIZE );
MicoUartInitialize( LUA_UART, &lua_uart_config, (ring_buffer_t*)&lua_rx_buffer );
mico_rtos_create_thread(NULL, MICO_DEFAULT_WORKER_PRIORITY, "lua_main_thread", lua_main_thread, 20*1024, 0);
#endif
// while(1) {;}
mico_rtos_delete_thread(NULL);
lua_printf("application_start exit\r\n");
return 0;
}
int application_start( void )
{
OSStatus err = kNoErr;
MicoInit( );
/*The notification message for the registered WiFi status change*/
err = MICOAddNotification( mico_notify_WIFI_STATUS_CHANGED, (void *)micoNotify_WifiStatusHandler );
require_noerr( err, exit );
memset(&wNetConfig, 0x0, sizeof(network_InitTypeDef_st));
strcpy((char*)wNetConfig.wifi_ssid, ap_ssid);
strcpy((char*)wNetConfig.wifi_key, ap_key);
wNetConfig.wifi_mode = Soft_AP;
wNetConfig.dhcpMode = DHCP_Server;
wNetConfig.wifi_retry_interval = 100;
strcpy((char*)wNetConfig.local_ip_addr, "192.168.0.1");
strcpy((char*)wNetConfig.net_mask, "255.255.255.0");
strcpy((char*)wNetConfig.dnsServer_ip_addr, "192.168.0.1");
micoWlanStart(&wNetConfig);
wifi_softap_log("ssid:%s key:%s", wNetConfig.wifi_ssid, wNetConfig.wifi_key);
exit:
return err;
}
int application_start( void )
{
OSStatus err = kNoErr;
is_easylink_success = 0;
MicoInit( );
/*The notification message for the registered WiFi status change*/
err = MICOAddNotification( mico_notify_WIFI_STATUS_CHANGED, (void *)micoNotify_WifiStatusHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_WIFI_CONNECT_FAILED, (void *)micoNotify_ConnectFailedHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_EASYLINK_WPS_COMPLETED, (void *)EasyLinkNotify_EasyLinkCompleteHandler );
require_noerr(err, exit);
err = MICOAddNotification( mico_notify_EASYLINK_GET_EXTRA_DATA, (void *)EasyLinkNotify_EasyLinkGetExtraDataHandler );
require_noerr(err, exit);
// Start the EasyLink thread
mico_rtos_init_semaphore(&easylink_sem, 1);
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "EASYLINK", easylink_thread, 0x800, NULL );
require_noerr_action( err, exit, wifi_easylink_log("ERROR: Unable to start the EasyLink thread.") );
return err;
exit:
wifi_easylink_log("ERROR, err: %d", err);
return err;
}
int application_start( void )
{
MicoInit( );
MICOAddNotification( mico_notify_WIFI_SCAN_COMPLETED, (void *)micoNotify_ApListCallback );
wifi_sacn_log("start scan mode, please wait...");
micoWlanStartScan( );
return kNoErr;
}
int application_start( void )
{
network_InitTypeDef_st wNetConfig;
#if MCU_POWERSAVE_ENABLED
MicoMcuPowerSaveConfig(true);
#endif
power_log( "Power measure program: RTOS and wlan initialized and start easylink" );
MicoInit( );
micoWlanStartEasyLinkPlus( MICO_NEVER_TIMEOUT );
mico_rtos_delete_thread( NULL );
return 0;
}
int application_start( void )
{
#if MCU_POWERSAVE_ENABLED
MicoMcuPowerSaveConfig(true);
#endif
power_log( "Power measure program: RTOS and wlan initialized and wlan is initialized" );
MicoInit( );
#if IEEE_POWERSAVE_ENABLED
micoWlanEnablePowerSave();
#endif
mico_rtos_delete_thread( NULL );
return 0;
}
int application_start( void )
{
network_InitTypeDef_adv_st wNetConfig;
int udp_fd = -1;
struct sockaddr_t addr;
socklen_t addrLen;
uint8_t *buf = NULL;
#if MCU_POWERSAVE_ENABLED
MicoMcuPowerSaveConfig(true);
#endif
power_log( "Power measure program: RTOS and wlan initialized and connect wlan, wait station up to measure" );
MicoInit( );
#if IEEE_POWERSAVE_ENABLED
micoWlanEnablePowerSave();
#endif
memset(&wNetConfig, 0x0, sizeof(network_InitTypeDef_adv_st));
strncpy((char*)wNetConfig.ap_info.ssid, "William Xu", 32);
wNetConfig.ap_info.security = SECURITY_TYPE_AUTO;
strncpy((char*)wNetConfig.key, "mx099555", 64);
wNetConfig.key_len = 8;
wNetConfig.dhcpMode = true;
wNetConfig.wifi_retry_interval = 100;
micoWlanStartAdv(&wNetConfig);
power_log("connect to %s.....", wNetConfig.ap_info.ssid);
buf = malloc(1024);
udp_fd = socket(AF_INET, SOCK_DGRM, IPPROTO_UDP);;
addr.s_port = 2000;
addr.s_ip = INADDR_ANY;
bind(udp_fd, &addr, sizeof(addr));
addr.s_port = 2001;
addr.s_ip = inet_addr( "192.168.2.1" );
connect( udp_fd, &addr, sizeof(addr) );
while(1) {
send( udp_fd, buf, 1024, 0 );
mico_thread_msleep( 10 );
}
mico_rtos_delete_thread( NULL );
return 0;
}
int application_start( void )
{
//start
// lua_printf( "\r\n\r\nMiCO starting...(Free memory %d bytes)\r\n",MicoGetMemoryInfo()->free_memory);
MicoInit();
//watch dog
MicoWdgInitialize( DEFAULT_WATCHDOG_TIMEOUT);
mico_init_timer(&_watchdog_reload_timer,DEFAULT_WATCHDOG_TIMEOUT/2, _watchdog_reload_timer_handler, NULL);
mico_start_timer(&_watchdog_reload_timer);
#if 0
#include "tm_stm32f4_usb_vcp.h"
lua_printf("\r\n\r\n TM_USB_VCP_Init:%d",TM_USB_VCP_Init());
uint8_t c;
//NVIC_SetVectorTable(NVIC_VectTab_FLASH, new_addr);
while(1)
{
if (TM_USB_VCP_GetStatus() == TM_USB_VCP_CONNECTED)
{
if (TM_USB_VCP_Getc(&c) == TM_USB_VCP_DATA_OK)
{
TM_USB_VCP_Putc(c);/* Return data back */
}
}
}
#endif
//usrinterface
//MicoCliInit();
#if 1
// lua_printf("Free memory %d bytes\r\n", MicoGetMemoryInfo()->free_memory);
lua_rx_data = (uint8_t*)malloc(INBUF_SIZE);
ring_buffer_init( (ring_buffer_t*)&lua_rx_buffer, (uint8_t*)lua_rx_data, INBUF_SIZE );
MicoUartInitialize( LUA_UART, &lua_uart_config, (ring_buffer_t*)&lua_rx_buffer );
mico_rtos_create_thread(NULL, MICO_DEFAULT_WORKER_PRIORITY, "lua_main_thread", lua_main_thread, 20*1024, 0);
#endif
// while(1) {;}
mico_rtos_delete_thread(NULL);
lua_printf("application_start exit\r\n");
return 0;
}
int application_start( void )
{
network_InitTypeDef_st wNetConfig;
#if MCU_POWERSAVE_ENABLED
MicoMcuPowerSaveConfig(true);
#endif
power_log( "Power measure program: RTOS and wlan initialized and setup soft ap" );
MicoInit( );
memset(&wNetConfig, 0, sizeof(network_InitTypeDef_st));
wNetConfig.wifi_mode = Soft_AP;
snprintf(wNetConfig.wifi_ssid, 32, "EasyLink_PM" );
strcpy((char*)wNetConfig.wifi_key, "");
strcpy((char*)wNetConfig.local_ip_addr, "10.10.10.1");
strcpy((char*)wNetConfig.net_mask, "255.255.255.0");
strcpy((char*)wNetConfig.gateway_ip_addr, "10.10.10.1");
wNetConfig.dhcpMode = DHCP_Server;
micoWlanStart(&wNetConfig);
mico_rtos_delete_thread( NULL );
return 0;
}
OSStatus system_network_daemen_start( mico_Context_t * const inContext )
{
IPStatusTypedef para;
MicoInit();
MicoSysLed(true);
system_log("Free memory %d bytes", MicoGetMemoryInfo()->free_memory);
micoWlanGetIPStatus(¶, Station);
formatMACAddr(inContext->micoStatus.mac, (char *)¶.mac);
MicoGetRfVer(inContext->micoStatus.rf_version, sizeof(inContext->micoStatus.rf_version));
inContext->micoStatus.rf_version[49] = 0x0;
system_log("MiCO library version: %s", MicoGetVer());
system_log("Wi-Fi driver version %s, mac %s", inContext->micoStatus.rf_version, inContext->micoStatus.mac);
if(inContext->flashContentInRam.micoSystemConfig.rfPowerSaveEnable == true){
micoWlanEnablePowerSave();
}
if(inContext->flashContentInRam.micoSystemConfig.mcuPowerSaveEnable == true){
MicoMcuPowerSaveConfig(true);
}
return kNoErr;
}
int application_start(void)
{
OSStatus err = kNoErr;
IPStatusTypedef para;
struct tm currentTime;
mico_rtc_time_t time;
char wifi_ver[64];
mico_log_trace();
#if 1
/*Read current configurations*/
context = ( mico_Context_t *)malloc(sizeof(mico_Context_t) );
require_action( context, exit, err = kNoMemoryErr );
memset(context, 0x0, sizeof(mico_Context_t));
mico_rtos_init_mutex(&context->flashContentInRam_mutex);
mico_rtos_init_semaphore(&context->micoStatus.sys_state_change_sem, 1);
MICOReadConfiguration( context );
err = MICOInitNotificationCenter ( context );
err = MICOAddNotification( mico_notify_READ_APP_INFO, (void *)micoNotify_ReadAppInfoHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_WIFI_CONNECT_FAILED, (void *)micoNotify_ConnectFailedHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_WIFI_Fatal_ERROR, (void *)micoNotify_WlanFatalErrHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_Stack_Overflow_ERROR, (void *)micoNotify_StackOverflowErrHandler );
require_noerr( err, exit );
#endif
/*wlan driver and tcpip init*/
MicoInit();
MicoSysLed(true);
/**********************add ethernet**********************/
add_ethernet();
//sleep(5000);
/*********************************************************/
mico_log("Free memory %d bytes", MicoGetMemoryInfo()->free_memory) ;
/* Enter test mode, call a build-in test function amd output on STDIO */
if(MicoShouldEnterMFGMode()==true)
mico_mfg_test();
/*Read current time from RTC.*/
MicoRtcGetTime(&time);
currentTime.tm_sec = time.sec;
currentTime.tm_min = time.min;
currentTime.tm_hour = time.hr;
currentTime.tm_mday = time.date;
currentTime.tm_wday = time.weekday;
currentTime.tm_mon = time.month - 1;
currentTime.tm_year = time.year + 100;
mico_log("Current Time: %s",asctime(¤tTime));
micoWlanGetIPStatus(¶, Station);
formatMACAddr(context->micoStatus.mac, (char *)¶.mac);
MicoGetRfVer(wifi_ver, sizeof(wifi_ver));
mico_log("%s mxchipWNet library version: %s", APP_INFO, MicoGetVer());
mico_log("Wi-Fi driver version %s, mac %s", wifi_ver, context->micoStatus.mac);
/*Start system monotor thread*/
err = MICOStartSystemMonitor(context);
require_noerr_action( err, exit, mico_log("ERROR: Unable to start the system monitor.") );
err = MICORegisterSystemMonitor(&mico_monitor, APPLICATION_WATCHDOG_TIMEOUT_SECONDS*1000);
require_noerr( err, exit );
mico_init_timer(&_watchdog_reload_timer,APPLICATION_WATCHDOG_TIMEOUT_SECONDS*1000 - 100, _watchdog_reload_timer_handler, NULL);
mico_start_timer(&_watchdog_reload_timer);
/* Regisist notifications */
err = MICOAddNotification( mico_notify_WIFI_STATUS_CHANGED, (void *)micoNotify_WifiStatusHandler );
require_noerr( err, exit );
/*************add ethernet********Why add twice?***********/
//add_ethernet();
if(context->flashContentInRam.micoSystemConfig.configured != allConfigured){
mico_log("Empty configuration. Starting configuration mode...");
#if (MICO_CONFIG_MODE == CONFIG_MODE_EASYLINK) || (MICO_CONFIG_MODE == CONFIG_MODE_EASYLINK_WITH_SOFTAP)
err = startEasyLink( context );
require_noerr( err, exit );
#elif (MICO_CONFIG_MODE == CONFIG_MODE_SOFT_AP)
err = startEasyLinkSoftAP( context );
require_noerr( err, exit );
#elif (MICO_CONFIG_MODE == CONFIG_MODE_AIRKISS)
err = startAirkiss( context );
require_noerr( err, exit );
#elif (MICO_CONFIG_MODE == CONFIG_MODE_WPS) || MICO_CONFIG_MODE == defined (CONFIG_MODE_WPS_WITH_SOFTAP)
err = startWPS( context );
require_noerr( err, exit );
#elif ( MICO_CONFIG_MODE == CONFIG_MODE_WAC)
WACPlatformParameters_t* WAC_Params = NULL;
WAC_Params = calloc(1, sizeof(WACPlatformParameters_t));
require(WAC_Params, exit);
str2hex((unsigned char *)para.mac, WAC_Params->macAddress, 6);
WAC_Params->isUnconfigured = 1;
WAC_Params->supportsAirPlay = 0;
WAC_Params->supportsAirPrint = 0;
WAC_Params->supports2_4GHzWiFi = 1;
WAC_Params->supports5GHzWiFi = 0;
WAC_Params->supportsWakeOnWireless = 0;
WAC_Params->firmwareRevision = FIRMWARE_REVISION;
WAC_Params->hardwareRevision = HARDWARE_REVISION;
WAC_Params->serialNumber = SERIAL_NUMBER;
WAC_Params->name = context->flashContentInRam.micoSystemConfig.name;
WAC_Params->model = MODEL;
WAC_Params->manufacturer = MANUFACTURER;
WAC_Params->numEAProtocols = 1;
WAC_Params->eaBundleSeedID = BUNDLE_SEED_ID;
WAC_Params->eaProtocols = (char **)eaProtocols;
err = startMFiWAC( context, WAC_Params, 1200);
free(WAC_Params);
require_noerr( err, exit );
#else
#error "Wi-Fi configuration mode is not defined"?
#endif
}
else{
mico_log("Available configuration. Starting Wi-Fi connection...");
err = MICOAddNotification( mico_notify_WiFI_PARA_CHANGED, (void *)micoNotify_WiFIParaChangedHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_DHCP_COMPLETED, (void *)micoNotify_DHCPCompleteHandler );
require_noerr( err, exit );
if(context->flashContentInRam.micoSystemConfig.rfPowerSaveEnable == true){
micoWlanEnablePowerSave();
}
if(context->flashContentInRam.micoSystemConfig.mcuPowerSaveEnable == true){
MicoMcuPowerSaveConfig(true);
}
/*Local configuration server*/
if(context->flashContentInRam.micoSystemConfig.configServerEnable == true){
err = MICOStartConfigServer(context);
require_noerr_action( err, exit, mico_log("ERROR: Unable to start the local server thread.") );
}
err = MICOStartNTPClient(context);
require_noerr_action( err, exit, mico_log("ERROR: Unable to start the NTP client thread.") );
/*Start mico application*/
err = MICOStartApplication( context );
require_noerr( err, exit );
_ConnectToAP( context );
}
mico_log("Free memory %d bytes", MicoGetMemoryInfo()->free_memory) ;
/*System status changed*/
while(mico_rtos_get_semaphore(&context->micoStatus.sys_state_change_sem, MICO_WAIT_FOREVER)==kNoErr){
switch(context->micoStatus.sys_state){
case eState_Normal:
break;
case eState_Software_Reset:
sendNotifySYSWillPowerOff();
mico_thread_msleep(500);
MicoSystemReboot();
break;
case eState_Wlan_Powerdown:
sendNotifySYSWillPowerOff();
mico_thread_msleep(500);
micoWlanPowerOff();
break;
case eState_Standby:
mico_log("Enter standby mode");
sendNotifySYSWillPowerOff();
mico_thread_msleep(200);
micoWlanPowerOff();
MicoSystemStandBy(MICO_WAIT_FOREVER);
break;
default:
break;
}
}
require_noerr_action( err, exit, mico_log("Closing main thread with err num: %d.", err) );
exit:
mico_rtos_delete_thread(NULL);
return kNoErr;
}
int application_start(void)
{
OSStatus err = kNoErr;
IPStatusTypedef para;
struct tm currentTime;
mico_rtc_time_t time;
char wifi_ver[64] = {0};
mico_log_trace();
/*Read current configurations*/
context = ( mico_Context_t *)malloc(sizeof(mico_Context_t) );
require_action( context, exit, err = kNoMemoryErr );
memset(context, 0x0, sizeof(mico_Context_t));
mico_rtos_init_mutex(&context->flashContentInRam_mutex);//ram互斥初始化
mico_rtos_init_semaphore(&context->micoStatus.sys_state_change_sem, 1);//系统状态信号量
mico_rtos_create_thread( NULL, MICO_APPLICATION_PRIORITY, "sys", _sys_state_thread, 800, NULL );
MICOReadConfiguration( context );//读flash数据
err = MICOInitNotificationCenter ( context );
err = MICOAddNotification( mico_notify_READ_APP_INFO, (void *)micoNotify_ReadAppInfoHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_WIFI_CONNECT_FAILED, (void *)micoNotify_ConnectFailedHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_WIFI_Fatal_ERROR, (void *)micoNotify_WlanFatalErrHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_Stack_Overflow_ERROR, (void *)micoNotify_StackOverflowErrHandler );
require_noerr( err, exit );
/*wlan driver and tcpip init*/
mico_log( "MiCO starting..." );
MicoInit();
#ifdef MICO_CLI_ENABLE
MicoCliInit();
#endif
MicoSysLed(true);
mico_log("Free memory %d bytes", MicoGetMemoryInfo()->free_memory);
micoWlanGetIPStatus(¶, Station);
formatMACAddr(context->micoStatus.mac, (char *)para.mac);
MicoGetRfVer(wifi_ver, sizeof(wifi_ver));
mico_log("ip = %s,mac=%s",para.ip,para.mac);
mico_log("%s mxchipWNet library version: %s", APP_INFO, MicoGetVer());
mico_log("Wi-Fi driver version %s, mac %s", wifi_ver, context->micoStatus.mac);
/*Start system monotor thread*/
//err = MICOStartSystemMonitor(context);
require_noerr_action( err, exit, mico_log("ERROR: Unable to start the system monitor.") );
err = MICORegisterSystemMonitor(&mico_monitor, APPLICATION_WATCHDOG_TIMEOUT_SECONDS*1000);
require_noerr( err, exit );
mico_init_timer(&_watchdog_reload_timer,APPLICATION_WATCHDOG_TIMEOUT_SECONDS*1000/2, _watchdog_reload_timer_handler, NULL);
mico_start_timer(&_watchdog_reload_timer);
/* Enter test mode, call a build-in test function amd output on MFG UART */
if(MicoShouldEnterMFGMode()==true){
mico_log( "Enter MFG mode by MFG button" );
mico_mfg_test(context);
}
/*Read current time from RTC.*/
if( MicoRtcGetTime(&time) == kNoErr ){
currentTime.tm_sec = time.sec;
currentTime.tm_min = time.min;
currentTime.tm_hour = time.hr;
currentTime.tm_mday = time.date;
currentTime.tm_wday = time.weekday;
currentTime.tm_mon = time.month - 1;
currentTime.tm_year = time.year + 100;
mico_log("Current Time: %s",asctime(¤tTime));
}else
mico_log("RTC function unsupported");
/* Regisist notifications */
err = MICOAddNotification( mico_notify_WIFI_STATUS_CHANGED, (void *)micoNotify_WifiStatusHandler );
require_noerr( err, exit );
if( context->flashContentInRam.micoSystemConfig.configured == wLanUnConfigured ||
context->flashContentInRam.micoSystemConfig.configured == unConfigured){
mico_log("Empty configuration. Starting configuration mode...");
//HERE TO config network
#if (MICO_CONFIG_MODE == CONFIG_MODE_EASYLINK) || (MICO_CONFIG_MODE == CONFIG_MODE_EASYLINK_WITH_SOFTAP)
err = startEasyLink( context );
require_noerr( err, exit );
#elif (MICO_CONFIG_MODE == CONFIG_MODE_SOFT_AP)
err = startEasyLinkSoftAP( context );
require_noerr( err, exit );
#elif (MICO_CONFIG_MODE == CONFIG_MODE_AIRKISS)
err = startAirkiss( context );
require_noerr( err, exit );
#elif (MICO_CONFIG_MODE == CONFIG_MODE_WPS) || MICO_CONFIG_MODE == defined (CONFIG_MODE_WPS_WITH_SOFTAP)
err = startWPS( context );
require_noerr( err, exit );
#elif ( MICO_CONFIG_MODE == CONFIG_MODE_WAC)
WACPlatformParameters_t* WAC_Params = NULL;
WAC_Params = calloc(1, sizeof(WACPlatformParameters_t));
require(WAC_Params, exit);
str2hex((unsigned char *)para.mac, WAC_Params->macAddress, 6);
WAC_Params->isUnconfigured = 1;
WAC_Params->supportsAirPlay = 0;
WAC_Params->supportsAirPrint = 0;
WAC_Params->supports2_4GHzWiFi = 1;
WAC_Params->supports5GHzWiFi = 0;
WAC_Params->supportsWakeOnWireless = 0;
WAC_Params->firmwareRevision = FIRMWARE_REVISION;
WAC_Params->hardwareRevision = HARDWARE_REVISION;
WAC_Params->serialNumber = SERIAL_NUMBER;
WAC_Params->name = context->flashContentInRam.micoSystemConfig.name;
WAC_Params->model = MODEL;
WAC_Params->manufacturer = MANUFACTURER;
WAC_Params->numEAProtocols = 1;
WAC_Params->eaBundleSeedID = BUNDLE_SEED_ID;
WAC_Params->eaProtocols = (char **)eaProtocols;
err = startMFiWAC( context, WAC_Params, MICO_I2C_CP, 1200 );
free(WAC_Params);
require_noerr( err, exit );
#else
#error "Wi-Fi configuration mode is not defined"
#endif
}
else{
mico_log("Available configuration. Starting Wi-Fi connection...");
_ConnectToAP( context );
}
#ifdef MFG_MODE_AUTO
if( context->flashContentInRam.micoSystemConfig.configured == mfgConfigured ){
mico_log( "Enter MFG mode automatically" );
mico_mfg_test(context);
mico_thread_sleep(MICO_NEVER_TIMEOUT);
}
#endif
err = MICOAddNotification( mico_notify_WiFI_PARA_CHANGED, (void *)micoNotify_WiFIParaChangedHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_DHCP_COMPLETED, (void *)micoNotify_DHCPCompleteHandler );
require_noerr( err, exit );
if(context->flashContentInRam.micoSystemConfig.rfPowerSaveEnable == true){
micoWlanEnablePowerSave();
}
if(context->flashContentInRam.micoSystemConfig.mcuPowerSaveEnable == true){
MicoMcuPowerSaveConfig(true);
}
/*Local configuration server*/
if(context->flashContentInRam.micoSystemConfig.configServerEnable == true){
err = MICOStartConfigServer(context);
require_noerr_action( err, exit, mico_log("ERROR: Unable to start the local server thread.") );
}
err = MICOStartNTPClient(context);
require_noerr_action( err, exit, mico_log("ERROR: Unable to start the NTP client thread.") );
/*Start mico application*/
err = MICOStartApplication( context );
require_noerr( err, exit );
mico_log("Free memory %d bytes", MicoGetMemoryInfo()->free_memory) ;
require_noerr_action( err, exit, mico_log("Closing main thread with err num: %d.", err) );
exit:
mico_rtos_delete_thread(NULL);
return kNoErr;
}
