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;
}
OSStatus system_notification_init( mico_Context_t * const inContext )
{
OSStatus err = kNoErr;
err = mico_system_notify_register( mico_notify_WIFI_CONNECT_FAILED, (void *)micoNotify_ConnectFailedHandler, inContext );
require_noerr( err, exit );
err = mico_system_notify_register( mico_notify_WIFI_Fatal_ERROR, (void *)micoNotify_WlanFatalErrHandler, inContext );
require_noerr( err, exit );
err = mico_system_notify_register( mico_notify_Stack_Overflow_ERROR, (void *)micoNotify_StackOverflowErrHandler, inContext );
require_noerr( err, exit );
err = mico_system_notify_register( mico_notify_DHCP_COMPLETED, (void *)micoNotify_DHCPCompleteHandler, inContext );
require_noerr( err, exit );
err = mico_system_notify_register( mico_notify_WIFI_STATUS_CHANGED, (void *)micoNotify_WifiStatusHandler, inContext );
require_noerr( err, exit );
err = mico_system_notify_register( mico_notify_WiFI_PARA_CHANGED, (void *)micoNotify_WiFIParaChangedHandler, inContext );
require_noerr( err, exit );
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_scan( lua_State* L )
{
OSStatus err = 0;
int tmo = mico_get_time();
wifi_scanned_print = 0;
if (lua_type(L, 1) == LUA_TFUNCTION || lua_type(L, 1) == LUA_TLIGHTFUNCTION) {
lua_pushvalue(L, 1); // copy argument (func) to the top of stack
if (wifi_scan_succeed != LUA_NOREF)
luaL_unref(L, LUA_REGISTRYINDEX, wifi_scan_succeed);
wifi_scan_succeed = luaL_ref(L, LUA_REGISTRYINDEX);
}
else {
if (wifi_scan_succeed != LUA_NOREF)
luaL_unref(L, LUA_REGISTRYINDEX, wifi_scan_succeed);
wifi_scan_succeed = LUA_NOREF;
if (lua_type(L, 1) == LUA_TNUMBER) {
int prn = luaL_checkinteger( L, 1 );
if (prn == 1) wifi_scanned_print = 1;
}
}
err = mico_system_notify_register( mico_notify_WIFI_SCAN_ADV_COMPLETED, (void *)_micoNotify_WiFi_Scan_OK, NULL );
require_noerr( err, exit );
gL = L;
wifi_scanned = 0;
micoWlanStartScanAdv();
tmo = mico_get_time();
if (wifi_scan_succeed == LUA_NOREF) {
while (wifi_scanned == 0) {
if ((mico_get_time() - tmo) > 8000) break;
mico_thread_msleep(100);
luaWdgReload();
}
if ((wifi_scanned == 1) && (wifi_scanned_print == 0)) {
return 2;
}
}
exit:
return 0;
}
int application_start( void )
{
OSStatus err = kNoErr;
/*Register user function for MiCO nitification: WiFi status changed */
err = mico_system_notify_register( mico_notify_WIFI_STATUS_CHANGED, (void *)micoNotify_WifiStatusHandler, NULL );
require_noerr( err, exit );
/* Start MiCO system functions according to mico_config.h */
err = mico_system_init( mico_system_context_init( 0 ) );
require_noerr( err, exit );
/* Start TCP server listener thread*/
err = mico_rtos_create_thread( NULL, MICO_APPLICATION_PRIORITY, "TCP_server", tcp_server_thread, 0x800, NULL );
require_noerr_string( err, exit, "ERROR: Unable to start the tcp server thread." );
exit:
mico_rtos_delete_thread( NULL );
return err;
}
int application_start( void )
{
OSStatus err = kNoErr;
/*Register user function for MiCO nitification: WiFi status changed */
err = mico_system_notify_register( mico_notify_WIFI_STATUS_CHANGED, (void *)micoNotify_WifiStatusHandler, NULL );
require_noerr( err, exit );
/* Start MiCO system functions according to mico_config.h */
err = mico_system_init( mico_system_context_init( 0 ) );
require_noerr( err, exit );
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "udp_unicast", udp_unicast_thread, 0x800, NULL );
require_noerr_string( err, exit, "ERROR: Unable to start the UDP thread." );
exit:
if( err != kNoErr )
udp_unicast_log("Thread exit with err: %d", err);
mico_rtos_delete_thread( NULL );
return err;
}
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;
char ipstr[16];
struct timeval_t t;
int remoteTcpClient_loopBack_fd = -1;
int remoteTcpClient_fd = -1;
uint8_t *inDataBuffer = NULL;
uint8_t *outDataBuffer = NULL;
mico_rtos_init_semaphore(&_wifiConnected_sem, 1);
/* Regisist notifications */
err = mico_system_notify_register( mico_notify_WIFI_STATUS_CHANGED, (void *)clientNotify_WifiStatusHandler, NULL );
require_noerr( err, exit );
inDataBuffer = malloc(wlanBufferLen);
require_action(inDataBuffer, exit, err = kNoMemoryErr);
outDataBuffer = malloc(wlanBufferLen);
require_action(inDataBuffer, exit, err = kNoMemoryErr);
/*Loopback fd, recv data from other thread */
remoteTcpClient_loopBack_fd = socket( AF_INET, SOCK_DGRM, IPPROTO_UDP );
require_action(IsValidSocket( remoteTcpClient_loopBack_fd ), exit, err = kNoResourcesErr );
addr.s_ip = IPADDR_LOOPBACK;
addr.s_port = REMOTE_TCP_CLIENT_LOOPBACK_PORT;
err = bind( remoteTcpClient_loopBack_fd, &addr, sizeof(addr) );
require_noerr( err, exit );
t.tv_sec = 4;
t.tv_usec = 0;
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);
Context->appStatus.isRemoteConnected = true;
client_log("Remote server connected at port: %d, fd: %d", Context->flashContentInRam.appConfig.remoteServerPort,
remoteTcpClient_fd);
}else{
FD_ZERO(&readfds);
FD_SET(remoteTcpClient_fd, &readfds);
FD_SET(remoteTcpClient_loopBack_fd, &readfds);
select(1, &readfds, NULL, NULL, &t);
/*recv UART data using loopback fd*/
if (FD_ISSET( remoteTcpClient_loopBack_fd, &readfds) ) {
len = recv( remoteTcpClient_loopBack_fd, outDataBuffer, wlanBufferLen, 0 );
SocketSend( remoteTcpClient_fd, outDataBuffer, len );
}
/*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);
Context->appStatus.isRemoteConnected = false;
goto ReConnWithDelay;
}
sppWlanCommandProcess(inDataBuffer, &len, remoteTcpClient_fd, Context);
}
Continue:
continue;
ReConnWithDelay:
if(remoteTcpClient_fd != -1){
SocketClose(&remoteTcpClient_fd);
}
sleep(CLOUD_RETRY);
}
}
exit:
if(inDataBuffer) free(inDataBuffer);
if(outDataBuffer) free(outDataBuffer);
if(remoteTcpClient_loopBack_fd != -1)
SocketClose(&remoteTcpClient_loopBack_fd);
client_log("Exit: Remote TCP client exit with err = %d", err);
mico_rtos_delete_thread(NULL);
return;
}
//=======================================
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;
}
//======================================
static int lwifi_startap( lua_State* L )
{
//4 stations Max
network_InitTypeDef_st wNetConfig;
size_t len=0;
memset(&wNetConfig, 0x0, sizeof(network_InitTypeDef_st));
if (!lua_istable(L, 1)) {
// ==== Call without parameters, return status ===
if (wifi_ap_started == 1) lua_pushboolean(L, true);
else lua_pushboolean(L, false);
return 1;
}
//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 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 return luaL_error( L, "arg: pwd needed" );
//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 {
strcpy(wNetConfig.local_ip_addr, "11.11.11.1");
}
//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 {
strcpy(wNetConfig.net_mask, "255.255.255.0");
}
//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 {
strcpy(wNetConfig.gateway_ip_addr,"11.11.11.1");
}
//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 {
strcpy(wNetConfig.dnsServer_ip_addr, "11.11.11.1");
}
//retry_interval
signed retry_interval = 0;
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;
//notify
gL = L;
if (wifi_status_changed_AP != LUA_NOREF)
luaL_unref(L, LUA_REGISTRYINDEX, wifi_status_changed_AP);
wifi_status_changed_AP = 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
if (wifi_status_changed_AP != LUA_NOREF)
luaL_unref(L, LUA_REGISTRYINDEX, wifi_status_changed_AP);
wifi_status_changed_AP = luaL_ref(L, LUA_REGISTRYINDEX);
}
mico_system_notify_register( mico_notify_WIFI_STATUS_CHANGED, (void *)_micoNotify_WifiStatusHandler, NULL );
//start
wifi_ap_started = 0;
wNetConfig.dhcpMode = DHCP_Server;
wNetConfig.wifi_mode = Soft_AP;
micoWlanStart(&wNetConfig);
int tmo = mico_get_time();
while (wifi_ap_started == 0) {
if ((mico_get_time() - tmo) > 1000) break;
mico_thread_msleep(10);
luaWdgReload();
}
if (wifi_ap_started == 1) lua_pushboolean(L, true);
else lua_pushboolean(L, false);
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 acaUartInterface_thread(void *inContext)
{
client_log_trace();
OSStatus err = kUnknownErr;
arrayent_net_status_t arg;
arrayent_return_e ret;
//int8_t retry = 0;
uint16_t len = 0;
static char property[150];
mico_rtos_init_semaphore(&_wifiConnected_sem, 1);//初始化信号量
/* Regisist notifications */
err = mico_system_notify_register( mico_notify_WIFI_STATUS_CHANGED, (void *)notify_WifiStatusHandler, (void *)inContext);//???
require_noerr( err, exit );
while(_wifiConnected == false){//after few time connected wifi success.???
mico_rtos_get_semaphore(&_wifiConnected_sem, 200000);
client_log("Waiting for Wi-Fi network...");
mico_thread_sleep(1);
}
user_modules_init();
OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_2, "Arrayent ");
OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_3, " Connecting... ");
OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_4, " ");
configureArrayent(inContext);
//Initialize Arrayent stack
client_log("Initializing Arrayent daemon...");
ret = ArrayentInit();
if(ret != ARRAYENT_SUCCESS) {
client_log("Failed to initialize Arrayent daemon.%d", ret);
return;
}
client_log("Arrayent daemon successfully initialized!");
//Wait for Arrayent to finish connecting to the server
do {
ret = ArrayentNetStatus(&arg);//get connecting status to server
if(ret != ARRAYENT_SUCCESS) {
client_log("Failed to connect to Arrayent network.");
}
client_log("Waiting for good network status.");
mico_thread_sleep(1);
} while(!(arg.connected_to_server));//after few time connected server success.
client_log("Connected to Arrayent network!\r\n");
_connection_lost = false;
OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_2, "Connected ");
OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_3, " Arrayent! ");
OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_4, " ");
ArrayentSetProperty("DC","0");
mico_thread_msleep(200);
ArrayentSetProperty("RGB","off");
err = mico_rtos_create_thread(NULL, MICO_DEFAULT_LIBRARY_PRIORITY, "update", update_property, STACK_SIZE_UART_RECV_THREAD, (void*)inContext);
require_noerr_action( err, exit, client_log("ERROR: Unable to start the update_property thread.") );
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "except", except_handle, STACK_SIZE_UART_RECV_THREAD, (void*)inContext);
require_noerr_action( err, exit, client_log("ERROR: Unable to start the except_handle thread.") );
while(1) {
//sure wifi connected.
if(_wifiConnected == false){
mico_rtos_get_semaphore(&_wifiConnected_sem, 200000);
continue;
}
//sure server connected.
if(_connection_lost && _wifiConnected){
do {
ret = ArrayentNetStatus(&arg);//get connecting status to server
if(ret != ARRAYENT_SUCCESS) {
client_log("Failed to connect to Arrayent network.");
}
client_log("Waiting for good network status.");
mico_thread_sleep(1);
} while(!(arg.connected_to_server));
_connection_lost = false;
}
len = sizeof(property);
if(ARRAYENT_SUCCESS==ArrayentRecvProperty(property,&len,10000)){//receive property data from server
client_log("property = %s\n\r",property);
if(0!=checkCmd(property, inContext)){//parse cmd success
//_response = false;
//retry = 1;
client_log("%s", property);
}
}
}
exit:
client_log("Exit: ACA App exit with err = %d", err);
mico_rtos_delete_thread(NULL);
return;
}
OSStatus MiCOStartSiteWhereService(app_context_t* const inContext)
{
sitewhere_log_trace();
OSStatus err = kUnknownErr;
char *bonjour_txt_record = NULL;
char *bonjour_txt_field = NULL;
// update wifi status
err = mico_system_notify_register( mico_notify_WIFI_STATUS_CHANGED, (void *)swNotify_WifiStatusHandler, inContext);
require_noerr_action(err, exit,
sitewhere_log("ERROR: mico_system_notify_register (mico_notify_WIFI_STATUS_CHANGED) failed!") );
// create uinque hardeareID like: MODEL-HARDWARE_REVISION-MAC
memset(hardwareId, '\0', sizeof(hardwareId));
sprintf(hardwareId, "Enjoy_%s-%s-%c%c%c%c%c%c",MODEL, HARDWARE_REVISION,
mico_system_context_get()->micoStatus.mac[9],
mico_system_context_get()->micoStatus.mac[10],
mico_system_context_get()->micoStatus.mac[12],
mico_system_context_get()->micoStatus.mac[13],
mico_system_context_get()->micoStatus.mac[15],
mico_system_context_get()->micoStatus.mac[16]
);
sitewhere_log("hardwareId=[%s]", hardwareId);
// create system topic like: SiteWhere/commands/<hardwareid>
memset(System1, '\0', sizeof(System1));
sprintf(System1, "%s/%s", "SiteWhere/system", hardwareId);
sitewhere_log("System1=[%s]", System1);
// create command topic like: SiteWhere/<system/hardwareid>
memset(Command1, '\0', sizeof(Command1));
sprintf(Command1, "%s/%s", "SiteWhere/commands", hardwareId);
sitewhere_log("Command1=[%s]", Command1);
// specificationToken
sitewhere_log("specificationToken=[%s]", specificationToken);
//------------------------------------------------------------------------
// update hardwareid in mdns text record
sitewhere_log("update bonjour txt record.");
bonjour_txt_record = malloc(550);
require_action(bonjour_txt_record, exit, err = kNoMemoryErr);
bonjour_txt_field = __strdup_trans_dot(inContext->mico_context->micoStatus.mac);
sprintf(bonjour_txt_record, "MAC=%s.", bonjour_txt_field);
free(bonjour_txt_field);
bonjour_txt_field = __strdup_trans_dot(hardwareId);
sprintf(bonjour_txt_record, "%sHardware ID=%s.", bonjour_txt_record, bonjour_txt_field);
free(bonjour_txt_field);
bonjour_txt_field = __strdup_trans_dot(FIRMWARE_REVISION);
sprintf(bonjour_txt_record, "%sFirmware Rev=%s.", bonjour_txt_record, bonjour_txt_field);
free(bonjour_txt_field);
bonjour_txt_field = __strdup_trans_dot(HARDWARE_REVISION);
sprintf(bonjour_txt_record, "%sHardware Rev=%s.", bonjour_txt_record, bonjour_txt_field);
free(bonjour_txt_field);
bonjour_txt_field = __strdup_trans_dot(MicoGetVer());
sprintf(bonjour_txt_record, "%sMICO OS Rev=%s.", bonjour_txt_record, bonjour_txt_field);
free(bonjour_txt_field);
bonjour_txt_field = __strdup_trans_dot(MODEL);
sprintf(bonjour_txt_record, "%sModel=%s.", bonjour_txt_record, bonjour_txt_field);
free(bonjour_txt_field);
bonjour_txt_field = __strdup_trans_dot(PROTOCOL);
sprintf(bonjour_txt_record, "%sProtocol=%s.", bonjour_txt_record, bonjour_txt_field);
free(bonjour_txt_field);
bonjour_txt_field = __strdup_trans_dot(MANUFACTURER);
sprintf(bonjour_txt_record, "%sManufacturer=%s.", bonjour_txt_record, bonjour_txt_field);
free(bonjour_txt_field);
sprintf(bonjour_txt_record, "%sSeed=%u.", bonjour_txt_record, inContext->mico_context->flashContentInRam.micoSystemConfig.seed);
mdns_update_txt_record(BONJOUR_SERVICE, Station, bonjour_txt_record);
if(NULL != bonjour_txt_record) free(bonjour_txt_record);
//------------------------------------------------------------------------
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "sitewhere",
sitewhere_main_thread, STACK_SIZE_SITEWHERE_MAIN_THREAD,
inContext );
require_noerr_action( err, exit, sitewhere_log("ERROR: Unable to start sitewhere thread.") );
//err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "MQTT Client",
// mqtt_loop_thread, 0xC00, (void*)inContext->mico_context );
//require_noerr_action( err, exit, sitewhere_log("ERROR: Unable to start the MQTT client thread.") );
exit:
return err;
}