//============================================== static int lwifi_station_getlink (lua_State* L ) { LinkStatusTypeDef link; memset(&link,0x00,sizeof(link)); micoWlanGetLinkStatus(&link); if (link.is_connected==0) { lua_pushstring(L, "disconnected"); lua_pushnil(L); lua_pushnil(L); lua_pushnil(L); } else { lua_pushstring(L, "connected"); lua_pushinteger(L, link.wifi_strength); lua_pushstring(L, (char*)link.ssid); char temp[20]={0}; char temp2[4]; temp[0]=0x00; for (int j = 0; j < 6; j++) { if ( j == 6 - 1 ) { sprintf(temp2,"%02X",link.bssid[j]); strcat(temp,temp2); } else { sprintf(temp2,"%02X:",link.bssid[j]); strcat(temp,temp2); } } lua_pushstring(L,temp); } return 4; }
/* MICO APP entrance */ OSStatus MICOStartApplication( mico_Context_t * const mico_context ) { app_log_trace(); OSStatus err = kNoErr; LinkStatusTypeDef wifi_link_status; require_action(mico_context, exit, err = kParamErr); app_log("Application version: %s", mico_context->flashContentInRam.appConfig.fogcloudConfig.romVersion); // LED on when Wi-Fi connected. MicoSysLed(false); // init application wifi link status do{ err = micoWlanGetLinkStatus(&wifi_link_status); if(kNoErr != err){ mico_thread_sleep(3); } }while(kNoErr != err); if(1 == wifi_link_status.is_connected){ mico_context->appStatus.isWifiConnected = true; } else{ mico_context->appStatus.isWifiConnected = false; } /* Bonjour for service searching */ if(mico_context->flashContentInRam.micoSystemConfig.bonjourEnable == true) { MICOStartBonjourService( Station, mico_context ); } /* start cloud service */ #if (MICO_CLOUD_TYPE == CLOUD_FOGCLOUD) app_log("MICO CloudService: FogCloud."); err = MicoStartFogCloudService( mico_context ); require_noerr_action( err, exit, app_log("ERROR: Unable to start FogCloud service.") ); #elif (MICO_CLOUD_TYPE == CLOUD_ALINK) app_log("MICO CloudService: Alink."); #elif (MICO_CLOUD_TYPE == CLOUD_DISABLED) app_log("MICO CloudService: disabled."); #else #error "MICO cloud service type is not defined"? #endif /* start user thread */ err = startUserMainThread( mico_context ); require_noerr_action( err, exit, app_log("ERROR: start user_main thread failed!") ); exit: return err; }
//stat = ftp.start() //=================================== static int lftp_start( lua_State* L ) { LinkStatusTypeDef wifi_link; int err = micoWlanGetLinkStatus( &wifi_link ); if ( wifi_link.is_connected == false ) { ftp_log("[FTP usr] WiFi NOT CONNECTED!\r\n" ); lua_pushinteger(L, -1); return 1; } if ( (gL == NULL) || (ftpCmdSocket == NULL) ) { ftp_log("[FTP usr] Execute ftp.new first!\r\n" ); lua_pushinteger(L, -2); return 1; } if (ftp_thread_is_started) { ftp_log("[FTP usr] Already started!\r\n" ); lua_pushinteger(L, -3); return 1; } mico_system_notify_register( mico_notify_TCP_CLIENT_CONNECTED, (void *)_micoNotify_FTPClientConnectedHandler, NULL ); // all setup, start the ftp thread if (!ftp_thread_is_started) { if (mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY-1, "Ftp_Thread", _thread_ftp, 1024, NULL) != kNoErr) { _ftp_deinit(0); ftp_log("[FTP usr] Create thread failed\r\n" ); lua_pushinteger(L, -4); return 1; } else ftp_thread_is_started = true; } if (ftpCmdSocket->logon_cb != LUA_NOREF) { lua_pushinteger(L, 0); return 1; } // wait max 10 sec for login uint32_t tmo = mico_get_time(); while ( (ftp_thread_is_started) && !(status & FTP_LOGGED) ) { if ((mico_get_time() - tmo) > 10000) break; mico_thread_msleep(100); luaWdgReload(); } if (!(status & FTP_LOGGED)) lua_pushinteger(L, -4); else lua_pushinteger(L, 0); return 1; }
//======================================= static int lwifi_startsta( lua_State* L ) { LinkStatusTypeDef link; network_InitTypeDef_st wNetConfig; size_t len=0; lua_system_param_t lua_system_param; uint8_t has_default = 0; signed retry_interval = 0; int con_wait = 0; int tmo = mico_get_time(); // check if wifi is already connected memset(&link, 0x00, sizeof(link)); micoWlanGetLinkStatus(&link); if (!lua_istable(L, 1)) { // ==== Call without parameters, return connection status === if (link.is_connected != 0) lua_pushboolean(L, true); else lua_pushboolean(L, false); return 1; } // ==== parameters exists, configure and start ==== if (wifi_sta_started == 1) _stopWifiSta(); memset(&wNetConfig, 0x0, sizeof(network_InitTypeDef_st)); // check if default params exists if (getLua_systemParams(&lua_system_param) == 1) { if ((strlen(lua_system_param.wifi_ssid) > 0) && (strlen(lua_system_param.wifi_key) > 0)) { has_default = 1; } } //wait for connection lua_getfield(L, 1, "wait"); if (!lua_isnil(L, -1)) { int wfc = luaL_checkinteger( L, -1 ); if ((wfc > 0) && (wfc < 16)) con_wait = wfc * 1000; else return luaL_error( L, "wait must be 1 ~ 15"); } //ssid lua_getfield(L, 1, "ssid"); if (!lua_isnil(L, -1)) { if ( lua_isstring(L, -1) ) { const char *ssid = luaL_checklstring( L, -1, &len ); if (len >= 32) return luaL_error( L, "ssid: <32" ); strncpy(wNetConfig.wifi_ssid,ssid,len); } else return luaL_error( L, "wrong arg type:ssid" ); } else if (has_default == 1) { strcpy(wNetConfig.wifi_ssid, lua_system_param.wifi_ssid); } else return luaL_error( L, "arg: ssid needed" ); //pwd lua_getfield(L, 1, "pwd"); if (!lua_isnil(L, -1)) { if ( lua_isstring(L, -1) ) { const char *pwd = luaL_checklstring( L, -1, &len ); if (len >= 64) return luaL_error( L, "pwd: <64" ); if (len > 0) strncpy(wNetConfig.wifi_key,pwd,len); else strcpy(wNetConfig.wifi_key,""); } else return luaL_error( L, "wrong arg type: pwd" ); } else if (has_default == 1) { strcpy(wNetConfig.wifi_key, lua_system_param.wifi_key); } else return luaL_error( L, "arg: pwd needed" ); //dhcp wNetConfig.dhcpMode = DHCP_Client; lua_getfield(L, 1, "dhcp"); if (!lua_isnil(L, -1)) { if ( lua_isstring(L, -1) ) { const char *pwd = luaL_checklstring( L, -1, &len ); if (strcmp(pwd, "disable") == 0) wNetConfig.dhcpMode = DHCP_Disable; } else return luaL_error( L, "wrong arg type: dhcp" ); } //ip lua_getfield(L, 1, "ip"); if (!lua_isnil(L, -1)) { if ( lua_isstring(L, -1) ) { const char *ip = luaL_checklstring( L, -1, &len ); if (len >= 16) return luaL_error( L, "ip: <16" ); if (is_valid_ip(ip) == false) return luaL_error( L, "ip invalid" ); strncpy(wNetConfig.local_ip_addr,ip,len); } else return luaL_error( L, "wrong arg type:ip" ); } else if (wNetConfig.dhcpMode == DHCP_Disable) return luaL_error( L, "arg: ip needed" ); //netmask lua_getfield(L, 1, "netmask"); if (!lua_isnil(L, -1)) { if ( lua_isstring(L, -1) ) { const char *netmask = luaL_checklstring( L, -1, &len ); if (len >= 16) return luaL_error( L, "netmask: <16" ); if (is_valid_ip(netmask) == false) return luaL_error( L, "netmask invalid" ); strncpy(wNetConfig.net_mask,netmask,len); } else return luaL_error( L, "wrong arg type: netmask" ); } else if (wNetConfig.dhcpMode == DHCP_Disable) return luaL_error( L, "arg: netmask needed" ); //gateway lua_getfield(L, 1, "gateway"); if (!lua_isnil(L, -1)) { if ( lua_isstring(L, -1) ) { const char *gateway = luaL_checklstring( L, -1, &len ); if (len >= 16) return luaL_error( L, "gateway: <16" ); if (is_valid_ip(gateway) == false) return luaL_error( L, "gateway invalid" ); strncpy(wNetConfig.gateway_ip_addr,gateway,len); } else return luaL_error( L, "wrong arg type: gateway" ); } else if(wNetConfig.dhcpMode == DHCP_Disable) return luaL_error( L, "arg: gateway needed" ); //dnsSrv lua_getfield(L, 1, "dnsSrv"); if (!lua_isnil(L, -1)) { if ( lua_isstring(L, -1) ) { const char *dnsSrv = luaL_checklstring( L, -1, &len ); if (len >= 16) return luaL_error( L, "dnsSrv: <16" ); if (is_valid_ip(dnsSrv) == false) return luaL_error( L, "dnsSrv invalid" ); strncpy(wNetConfig.dnsServer_ip_addr,dnsSrv,len); } else return luaL_error( L, "wrong arg type: dnsSrv" ); } else if (wNetConfig.dhcpMode == DHCP_Disable) return luaL_error( L, "arg: dnsSrv needed" ); //retry_interval lua_getfield(L, 1, "retry_interval"); if (!lua_isnil(L, -1)) { retry_interval = (signed)luaL_checknumber( L, -1 ); if (retry_interval < 0) return luaL_error( L, "retry_interval: >=0ms" ); if (retry_interval == 0) retry_interval = 0x7FFFFFFF; } else retry_interval = 1000; wNetConfig.wifi_retry_interval = retry_interval; gL = L; //notify, set CB function for wifi state change if (wifi_status_changed_STA != LUA_NOREF) luaL_unref(L, LUA_REGISTRYINDEX, wifi_status_changed_STA); wifi_status_changed_STA = LUA_NOREF; if (lua_type(L, 2) == LUA_TFUNCTION || lua_type(L, 2) == LUA_TLIGHTFUNCTION) { lua_pushvalue(L, 2); // copy argument (func) to the top of stack wifi_status_changed_STA = luaL_ref(L, LUA_REGISTRYINDEX); } mico_system_notify_register( mico_notify_WIFI_STATUS_CHANGED, (void *)_micoNotify_WifiStatusHandler, NULL ); //start wNetConfig.wifi_mode = Station; micoWlanStart(&wNetConfig); wifi_sta_started = 1; if (con_wait == 0) { lua_pushboolean(L, false); return 1; } tmo = mico_get_time(); micoWlanGetLinkStatus(&link); while (link.is_connected == 0) { if ((mico_get_time() - tmo) > con_wait) break; mico_thread_msleep(50); luaWdgReload(); micoWlanGetLinkStatus(&link); } if (link.is_connected == 0) lua_pushboolean(L, false); else lua_pushboolean(L, true); return 1; }
int application_start(void) { app_log_trace(); OSStatus err = kNoErr; app_context_t* app_context; mico_Context_t* mico_context; LinkStatusTypeDef wifi_link_status; /* Create application context */ app_context = ( app_context_t *)calloc(1, sizeof(app_context_t) ); require_action( app_context, exit, err = kNoMemoryErr ); /* Create mico system context and read application's config data from flash */ mico_context = mico_system_context_init( sizeof( application_config_t) ); require_action(mico_context, exit, err = kNoResourcesErr); app_context->appConfig = mico_system_context_get_user_data( mico_context ); app_context->mico_context = mico_context; app_context_global = app_context; /* user params restore check */ if(app_context->appConfig->configDataVer != CONFIGURATION_VERSION){ err = mico_system_context_restore(mico_context); require_noerr( err, exit ); } /* mico system initialize */ err = mico_system_init( mico_context ); require_noerr( err, exit ); MicoSysLed(true); // fix for AP down problem err = mico_system_notify_register( mico_notify_WIFI_CONNECT_FAILED, (void *)appNotify_ConnectFailedHandler, app_context->mico_context ); require_noerr_action(err, exit, app_log("ERROR: MICOAddNotification (mico_notify_WIFI_CONNECT_FAILED) failed!") ); //#ifdef USE_MiCOKit_EXT // /* user test mode to test MiCOKit-EXT board */ // if(MicoExtShouldEnterTestMode()){ // app_log("Enter ext-board test mode by key2."); // micokit_ext_mfg_test(mico_context); // } //#endif // block here if no wifi configuration. while(1){ if( mico_context->flashContentInRam.micoSystemConfig.configured == wLanUnConfigured || mico_context->flashContentInRam.micoSystemConfig.configured == unConfigured){ mico_thread_msleep(100); } else{ break; } } /* Bonjour for service searching */ MICOStartBonjourService( Station, app_context ); /* check wifi link status */ do{ err = micoWlanGetLinkStatus(&wifi_link_status); if(kNoErr != err){ mico_thread_sleep(3); } }while(kNoErr != err); if(1 == wifi_link_status.is_connected){ app_context->appStatus.isWifiConnected = true; MicoRfLed(true); } else{ app_context->appStatus.isWifiConnected = false; MicoRfLed(false); } /* start cloud service */ #if (MICO_CLOUD_TYPE == CLOUD_FOGCLOUD) app_log("MICO CloudService: FogCloud."); err = MiCOStartFogCloudService( app_context ); require_noerr_action( err, exit, app_log("ERROR: Unable to start FogCloud service.") ); #elif (MICO_CLOUD_TYPE == CLOUD_ALINK) app_log("MICO CloudService: Alink."); #elif (MICO_CLOUD_TYPE == CLOUD_DISABLED) app_log("MICO CloudService: disabled."); #else #error "MICO cloud service type is not defined"? #endif /* start user thread */ err = startUserMainThread( app_context ); require_noerr_action( err, exit, app_log("ERROR: start user_main thread failed!") ); exit: mico_rtos_delete_thread(NULL); return err; }
void NTPClient_thread(void *arg) { ntp_log_trace(); OSStatus err = kUnknownErr; UNUSED_PARAMETER( arg ); int Ntp_fd = -1; fd_set readfds; struct timeval_t t ; struct sockaddr_t addr; socklen_t addrLen; char ipstr[16]; unsigned int trans_sec, current; struct NtpPacket outpacket ,inpacket; struct tm *currentTime; mico_rtc_time_t time; LinkStatusTypeDef wifi_link; int contry = 0; /* Regisist notifications */ err = mico_system_notify_register( mico_notify_WIFI_STATUS_CHANGED, (void *)ntpNotify_WifiStatusHandler, NULL ); require_noerr( err, exit ); memset(&outpacket,0x0,sizeof(outpacket)); memset(&inpacket,0x0,sizeof(inpacket)); outpacket.flags = NTP_Flags; outpacket.stratum = NTP_Stratum; outpacket.poll = NTP_Poll; outpacket.precision = NTP_Precision; outpacket.root_delay = NTP_Root_Delay; outpacket.root_dispersion = NTP_Root_Dispersion; err = micoWlanGetLinkStatus( &wifi_link ); require_noerr( err, exit ); if( wifi_link.is_connected == true ) _wifiConnected = true; if(_wifiConnected == false) mico_rtos_get_semaphore(&_wifiConnected_sem, MICO_WAIT_FOREVER); Ntp_fd = socket(AF_INET, SOCK_DGRM, IPPROTO_UDP); require_action(IsValidSocket( Ntp_fd ), exit, err = kNoResourcesErr ); addr.s_ip = INADDR_ANY; addr.s_port = 45000; err = bind(Ntp_fd, &addr, sizeof(addr)); err = kNoErr; require_noerr(err, exit); contry=0; while(1) { //err = gethostbyname((char *)NTP_Server, (uint8_t *)ipstr, 16); err = gethostbyname(NTP_Server, (uint8_t *)ipstr, 16); contry+=1; if (contry > 4) { require_noerr(err, exit); } else { require_noerr(err, ReConnWithDelay); } ntp_log("NTP server address: %s",ipstr); break; ReConnWithDelay: mico_thread_sleep(5); } addr.s_ip = inet_addr(ipstr); addr.s_port = NTP_Port; t.tv_sec = 5; t.tv_usec = 0; while(1) { require_action(sendto(Ntp_fd, &outpacket,sizeof(outpacket), 0, &addr, sizeof(addr)), exit, err = kNotWritableErr); FD_ZERO(&readfds); FD_SET(Ntp_fd, &readfds); select(1, &readfds, NULL, NULL, &t); if(FD_ISSET(Ntp_fd, &readfds)) { require_action(recvfrom(Ntp_fd, &inpacket, sizeof(struct NtpPacket), 0, &addr, &addrLen)>=0, exit, err = kNotReadableErr); trans_sec = inpacket.trans_ts_sec; trans_sec = ntohl(trans_sec); current = trans_sec - UNIX_OFFSET + (ntp_time_zone*3600); ntp_log("Time Synchronised, %s, tz=%d, from %s\n\r",asctime(gmtime(¤t)),ntp_time_zone, NTP_Server); //currentTime = localtime(¤t); currentTime = gmtime(¤t); time.sec = currentTime->tm_sec; time.min = currentTime->tm_min ; time.hr = currentTime->tm_hour; time.date = currentTime->tm_mday; time.weekday = currentTime->tm_wday; time.month = currentTime->tm_mon + 1; time.year = (currentTime->tm_year + 1900)%100; MicoRtcSetTime( &time ); goto exit; } } exit: if( err!=kNoErr )ntp_log("Exit: NTP client exit with err = %d", err); mico_system_notify_remove( mico_notify_WIFI_STATUS_CHANGED, (void *)ntpNotify_WifiStatusHandler ); if(_wifiConnected_sem) mico_rtos_deinit_semaphore(&_wifiConnected_sem); SocketClose(&Ntp_fd); mico_rtos_delete_thread(NULL); return; }
void remoteTcpClient_thread(void *inContext) { client_log_trace(); OSStatus err = kUnknownErr; int len; mico_Context_t *Context = inContext; struct sockaddr_t addr; fd_set readfds; fd_set writeSet; char ipstr[16]; struct timeval_t t; int remoteTcpClient_fd = -1; uint8_t *inDataBuffer = NULL; int eventFd = -1; mico_queue_t queue; socket_msg_t *msg; LinkStatusTypeDef wifi_link; int sent_len, errno; mico_rtos_init_semaphore(&_wifiConnected_sem, 1); /* Regisist notifications */ err = MICOAddNotification( mico_notify_WIFI_STATUS_CHANGED, (void *)clientNotify_WifiStatusHandler ); require_noerr( err, exit ); inDataBuffer = malloc(wlanBufferLen); require_action(inDataBuffer, exit, err = kNoMemoryErr); err = micoWlanGetLinkStatus( &wifi_link ); require_noerr( err, exit ); if( wifi_link.is_connected == true ) _wifiConnected = true; while(1) { if(remoteTcpClient_fd == -1 ) { if(_wifiConnected == false){ require_action_quiet(mico_rtos_get_semaphore(&_wifiConnected_sem, 200000) == kNoErr, Continue, err = kTimeoutErr); } err = gethostbyname((char *)Context->flashContentInRam.appConfig.remoteServerDomain, (uint8_t *)ipstr, 16); require_noerr(err, ReConnWithDelay); remoteTcpClient_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); addr.s_ip = inet_addr(ipstr); addr.s_port = Context->flashContentInRam.appConfig.remoteServerPort; err = connect(remoteTcpClient_fd, &addr, sizeof(addr)); require_noerr_quiet(err, ReConnWithDelay); client_log("Remote server connected at port: %d, fd: %d", Context->flashContentInRam.appConfig.remoteServerPort, remoteTcpClient_fd); err = socket_queue_create(Context, &queue); require_noerr( err, exit ); eventFd = mico_create_event_fd(queue); if (eventFd < 0) { client_log("create event fd error"); socket_queue_delete(Context, &queue); goto ReConnWithDelay; } }else{ FD_ZERO(&readfds); FD_SET(remoteTcpClient_fd, &readfds); FD_SET(eventFd, &readfds); FD_ZERO(&writeSet ); FD_SET(remoteTcpClient_fd, &writeSet ); t.tv_sec = 4; t.tv_usec = 0; select(1, &readfds, &writeSet, NULL, &t); /* send UART data */ if ((FD_ISSET( eventFd, &readfds )) && (FD_ISSET(remoteTcpClient_fd, &writeSet ))) {// have data and can write if (kNoErr == mico_rtos_pop_from_queue( &queue, &msg, 0)) { sent_len = write(remoteTcpClient_fd, msg->data, msg->len); if (sent_len <= 0) { len = sizeof(errno); getsockopt(remoteTcpClient_fd, SOL_SOCKET, SO_ERROR, &errno, &len); socket_msg_free(msg); if (errno != ENOMEM) { client_log("write error, fd: %d, errno %d", remoteTcpClient_fd,errno ); goto ReConnWithDelay; } } else { socket_msg_free(msg); } } } /*recv wlan data using remote client fd*/ if (FD_ISSET(remoteTcpClient_fd, &readfds)) { len = recv(remoteTcpClient_fd, inDataBuffer, wlanBufferLen, 0); if(len <= 0) { client_log("Remote client closed, fd: %d", remoteTcpClient_fd); goto ReConnWithDelay; } sppWlanCommandProcess(inDataBuffer, &len, remoteTcpClient_fd, Context); } Continue: continue; ReConnWithDelay: if (eventFd >= 0) { mico_delete_event_fd(eventFd); eventFd = -1; socket_queue_delete(Context, &queue); } if(remoteTcpClient_fd != -1){ SocketClose(&remoteTcpClient_fd); } sleep(CLOUD_RETRY); } } exit: if(inDataBuffer) free(inDataBuffer); client_log("Exit: Remote TCP client exit with err = %d", err); mico_rtos_delete_thread(NULL); return; }
int application_start(void) { app_log_trace(); OSStatus err = kNoErr; app_context_t* app_context; mico_Context_t* mico_context; LinkStatusTypeDef wifi_link_status; /* Create application context */ app_context = ( app_context_t *)calloc(1, sizeof(app_context_t) ); require_action( app_context, exit, err = kNoMemoryErr ); /* Create mico system context and read application's config data from flash */ mico_context = mico_system_context_init( sizeof( application_config_t) ); require_action(mico_context, exit, err = kNoResourcesErr); app_context->appConfig = mico_system_context_get_user_data( mico_context ); app_context->mico_context = mico_context; /* user params restore check */ if(app_context->appConfig->configDataVer != CONFIGURATION_VERSION){ err = mico_system_context_restore(mico_context); require_noerr( err, exit ); } /* mico system initialize */ err = mico_system_init( mico_context ); require_noerr( err, exit ); MicoSysLed(true); /* Bonjour for service searching */ MICOStartBonjourService( Station, app_context ); /* user test mode: MiCOKit-EXT */ /* check wifi link status */ do{ err = micoWlanGetLinkStatus(&wifi_link_status); if(kNoErr != err){ mico_thread_sleep(3); } }while(kNoErr != err); if(1 == wifi_link_status.is_connected){ app_context->appStatus.isWifiConnected = true; MicoRfLed(true); } else{ app_context->appStatus.isWifiConnected = false; MicoRfLed(false); } /* start cloud service */ #if (MICO_CLOUD_TYPE == CLOUD_FOGCLOUD) app_log("MICO CloudService: FogCloud."); err = MiCOStartFogCloudService( app_context ); require_noerr_action( err, exit, app_log("ERROR: Unable to start FogCloud service.") ); #elif (MICO_CLOUD_TYPE == CLOUD_ALINK) app_log("MICO CloudService: Alink."); #elif (MICO_CLOUD_TYPE == CLOUD_SITEWHERE) app_log("MICO CloudService: SiteWhere."); err = MiCOStartSiteWhereService( app_context ); require_noerr_action( err, exit, app_log("ERROR: Unable to start SiteWhere service.") ); #elif (MICO_CLOUD_TYPE == CLOUD_DISABLED) app_log("MICO CloudService: disabled."); #else #error "MICO cloud service type is not defined"? #endif /* start user thread */ err = startUserMainThread( app_context ); require_noerr_action( err, exit, app_log("ERROR: start user_main thread failed!") ); exit: mico_rtos_delete_thread(NULL); return err; }