void CGameNet::Update(float _dt)
{
if (mNetState == ENetState::None)
{
}
else if (mNetState == ENetState::Connected)
{
}
else if (mNetState == ENetState::Connected)
{
if (mOnConnectDlg)
mOnConnectDlg(true);
_changeState(ENetState::Networking);
}
else if (mNetState == ENetState::Networking)
{
int a = 1;
}
else if (mNetState == ENetState::Disconnected)
{
if (mOnDisconnectDlg)
mOnDisconnectDlg(true);
_changeState(ENetState::Reconnect);
}
else if (mNetState == ENetState::Disconnected)
{
}
}
void SSMLoadOnlineConfig_Enter(void)
{
if(appGWActivationData.configuration.id[0] == '\0')
{
_changeState(STATE_NEEDS_MORE_CONFIG);
}
else if(appGWActivationData.configuration.key[0] == '\0')
{
_changeState(STATE_ACTIVATING);
}
else
{
_changeState(STATE_DOWNLOAD_LORA_CONFIG);
}
}
void CGameNet::NotifyDisconnected()
{
printf("--- NotifyDisconnected\n");
mSendThRunnable = false;
mRecvThRunnable = false;
_changeState(ENetState::Disconnected);
}
bool CGameNet::_connect(std::string _ip, int _port)
{
mIp = _ip;
mPort = _port;
if (mNetSocket == NULL)
{
mNetSocket = new CNetSocket();
}
bool result = true;
if (!mNetSocket->Initialize())
result = false;
int errCode = 0;
if (result && mNetSocket->Connect(_ip.c_str(), _port, errCode))
{
printf("---@@@ connect to %s:%d success @@@---\n", _ip.c_str(), _port);
mSendThRunnable = true;
mRecvThRunnable = true;
_start(); //链接成功开始工作线程
//if (mOnConnectDlg)
// mOnConnectDlg(true);
_changeState(ENetState::Connected);
return true;
}
else
{
printf("--------- connect fail, errCode:%f\n", errCode);
//mSendThRunnable = false;
//mRecvThRunnable = false;
if (mOnConnectDlg)
mOnConnectDlg(false);
return false;
}
}
void SSMWaitForInternet_Enter(void)
{
_changeState(STATE_WAIT_FOR_NETWORK);
}
void SSMWaitForInternet_Tasks(void)
{
switch(_state)
{
case STATE_WAIT_FOR_NETWORK:
if(APP_ETH_Has_Link())
{
SYS_PRINT("INET: Gateway has Ethernet\r\n");
_changeState(STATE_SETTLE);
}
else if(!appWifiData.valid)
{
SYS_PRINT("INET: No Ethernet and no WiFi config\r\n");
_changeState(STATE_AP_ONLY);
}
if(APP_WIFI_Has_LinkINFRA())
{
SYS_PRINT("INET: Gateway has WiFi\r\n");
_changeState(STATE_SETTLE);
}
break;
case STATE_AP_ONLY:
if(APP_ETH_Has_Link())
{
_changeState(STATE_WAIT_FOR_NETWORK);
}
else if(appWifiData.valid && ((SYS_TMR_TickCountGet() - wifiRetryStartTick) >=
(SYS_TMR_TickCounterFrequencyGet() * WIFI_RETRY_TIMEOUT)))
{ // REVIEW: Use isElapsed kind of function
if(APP_WIFI_Has_LinkAP())
{
if(firstTimeAPReconnectTimeout)
{
SYS_PRINT("INET: Not trying to connect to WiFi router again because client is connected (after "
"%d seconds)\r\n",
(SYS_TMR_TickCountGet() - wifiRetryStartTick) / SYS_TMR_TickCounterFrequencyGet());
firstTimeAPReconnectTimeout = false;
}
}
else
{
SYS_PRINT("INET: Trying to connect to WiFi router again (after %d seconds)\r\n",
(SYS_TMR_TickCountGet() - wifiRetryStartTick) / SYS_TMR_TickCounterFrequencyGet());
_changeState(STATE_WAIT_FOR_NETWORK);
}
}
break;
case STATE_SETTLE:
if((SYS_TMR_TickCountGet() - settleStartTick) >= (SYS_TMR_TickCounterFrequencyGet() * 5))
{
_changeState(STATE_PING_PROBE);
}
break;
case STATE_PING_PROBE:
if(!ping_probe_sent)
{
IPV4_ADDR googledns = {0};
googledns.v[0] = 8;
googledns.v[1] = 8;
googledns.v[2] = 4;
googledns.v[3] = 4;
ping_probe_reply_received = false;
SYS_PRINT("INET: Ping probe\r\n");
if(TCPIP_ICMP_EchoRequestSend(TCPIP_STACK_IndexToNet(WIFI_INTERFACE_NUM), &googledns, 0, 0x1234) !=
ICMP_ECHO_OK)
{
SYS_PRINT("INET: Error sending probe on WiFi\r\n");
}
if(TCPIP_ICMP_EchoRequestSend(TCPIP_STACK_IndexToNet(ETH_INTERFACE_NUM), &googledns, 0, 0x1234) !=
ICMP_ECHO_OK)
{
SYS_PRINT("INET: Error sending probe on Eth\r\n");
}
ping_probe_sent = true;
}
else if(ping_probe_reply_received)
{
SYS_PRINT("INET: Ping response from %s, set as default\r\n",
TCPIP_STACK_NetNameGet(TCPIP_STACK_NetDefaultGet()));
if(ntpEverSynchronized)
{
_changeState(STATE_DONE);
}
else
{
_changeState(STATE_WAIT_FOR_NTP);
}
break;
}
else
{
if((SYS_TMR_TickCountGet() - pingStartTick) >=
(SYS_TMR_TickCounterFrequencyGet() * PING_TIMEOUT)) // REVIEW: Use isElapsed kind of function
{
SYS_PRINT("INET: Ping Timeout of :%d seconds\r\n", PING_TIMEOUT);
pingStartTick = SYS_TMR_TickCountGet();
ping_probe_sent = false;
ping_probe_reply_received = false;
if(ping_retry >= PING_RETRIES)
{
// TODO: find a proper recovery -> _changeState(STATE_WAIT_FOR_NETWORK);
RebootWithMessage("Ping timeout %d retries, rebooting", PING_RETRIES);
}
ping_retry++;
}
}
break;
case STATE_WAIT_FOR_NTP:
{
uint32_t lastUpdate = 0;
TCPIP_SNTP_TimeStampGet(NULL, &lastUpdate);
if(lastUpdate != 0)
{ // If at least once NTP succeeded
ntpEverSynchronized = true;
_changeState(STATE_DONE);
}
else
{
if((SYS_TMR_TickCountGet() - ntpStartTick) >= (SYS_TMR_TickCounterFrequencyGet() * NTP_TIMEOUT))
{ // REVIEW: Use isElapsed kind of function
SYS_PRINT("INET: Not received any NTP response. Wait for network again (after %d seconds).\r\n",
(SYS_TMR_TickCountGet() - ntpStartTick) / SYS_TMR_TickCounterFrequencyGet());
_changeState(STATE_WAIT_FOR_NETWORK);
}
else if(TCPIP_SNTP_ConnectionInitiate() == SNTP_RES_OK)
{
SYS_PRINT("INET: Initiated NTP request.\r\n");
}
}
break;
}
case STATE_DONE:
break;
}
}
void _start()
{ if (_matchLine(THunk)) _changeState(SHunk); }
void SpawnDiggerTile::_processInputEvent( int nEventID )
{
if( nEventID == E_SDE_DEGENERATE )
_changeState( E_SDS_SOIL );
}
void SSMLoadOnlineConfig_Tasks(void)
{
switch(_state)
{
case STATE_NEEDS_MORE_CONFIG:
// TODO: what do we do then? Display on status page?
break;
case STATE_ACTIVATING:
{
if(APP_SERIALFLASH_IsReady())
{
APP_Activation_Tasks();
switch(APP_Activation_State())
{ // REVIEW: don't check internal state, but via test function
case APP_ACTIVATION_BARE_DONE:
if(strcmp(appGWActivationData.configuration.key, "") == 0)
{
FATAL("Activation done, but key not filled");
}
SYS_PRINT("\r\nCNFG: Valid key, proceeding\r\n");
_changeState(STATE_ERASING_ACTIVATION_KEY);
break;
case APP_ACTIVATION_BARE_WAS_ACTIVATED:
// invalid gateway id, wipe id, start over.
SYS_PRINT("\r\nCNFG: Was already activated, wait for a key to be configured\r\n");
_changeState(STATE_NEEDS_MORE_CONFIG);
break;
case APP_ACTIVATION_BARE_NON_EXISTING_ID:
SYS_PRINT("\r\nCNFG: Non existing ID, please register this ID with The Things Network\r\n");
_changeState(STATE_NEEDS_MORE_CONFIG);
break;
case APP_ACTIVATION_BARE_ERROR:
SYS_PRINT("\r\nCNFG: Activation failed\r\n");
ErrorMessageWarning_Set(ERROR_MESSAGE_WARNING_HTTP_COMMUNICATION_FAILURE_ACTIVATION);
_changeState(STATE_COMMUNICATION_ERROR);
break;
}
}
break;
}
case STATE_ERASING_ACTIVATION_KEY:
if(APP_SERIALFLASH_IsReady())
{
_changeState(STATE_STORING_ACTIVATION_KEY);
}
break;
case STATE_STORING_ACTIVATION_KEY:
if(APP_SERIALFLASH_IsReady())
{
SYS_PRINT("\r\nCNFG: Gateway Activated\r\n");
_changeState(STATE_DOWNLOAD_LORA_CONFIG);
}
break;
case STATE_DOWNLOAD_LORA_CONFIG:
APP_Configuration_Tasks();
switch(APP_Configuration_State())
{ // REVIEW: don't check internal state, but via test function
case APP_CONFIGURATION_DONE:
if(appGWActivationData.locked)
{
_changeState(STATE_DOWNLOAD_FREQPLAN);
}
else
{
_changeState(STATE_LOCK_ACTIVATION);
}
break;
case APP_CONFIGURATION_INCOMPLETE:
_changeState(STATE_NEEDS_MORE_CONFIG);
break;
case APP_CONFIGURATION_NON_EXISTING_ID:
// invalid gateway id, wipe id, start over.
SYS_PRINT("\r\nCNFG: Non existing gateway ID, wiping and starting over\r\n");
appGWActivationData.configuration.id[0] = '\0';
appGWActivationData.configuration.key[0] = '\0';
_changeState(STATE_NEEDS_MORE_CONFIG);
break;
case APP_CONFIGURATION_KEY_FAILURE:
// invalid gateway key, wipe key start over.
SYS_PRINT("\r\nCNFG: Invalid gateway key, wiping and starting over\r\n");
appGWActivationData.configuration.key[0] = '\0';
_changeState(STATE_ACTIVATING);
break;
case APP_CONFIGURATION_SERVER_BUSY:
if(SYS_TMR_TickCountGet() - reconnectDelayStartTick >=
SYS_TMR_TickCounterFrequencyGet() *
RECONNECT_DELAY_TIMEOUT) // REVIEW: use something like isElapsed function
{
SYS_PRINT("\r\nCNFG: Server busy, retry\r\n");
_changeState(STATE_DOWNLOAD_LORA_CONFIG);
}
break;
case APP_CONFIGURATION_ERROR:
SYS_PRINT("\r\nCNFG: Downloading gateway configuration failed\r\n");
_changeState(STATE_COMMUNICATION_ERROR);
ErrorMessageWarning_Set(ERROR_MESSAGE_WARNING_HTTP_COMMUNICATION_FAILURE_CONFIGURATION);
break;
default:
break;
}
break;
case STATE_LOCK_ACTIVATION:
if(APP_SERIALFLASH_IsReady())
{
SYS_PRINT("\r\nCNFG: Gateway activation locked\r\n");
_changeState(STATE_DOWNLOAD_FREQPLAN);
}
break;
case STATE_DOWNLOAD_FREQPLAN:
// Fetch lora module configuration
if(SYS_TMR_TickCountGet() - freqDelayStartTick <= SYS_TMR_TickCounterFrequencyGet() * 2)
{
break; // take a little break after the settings fetch to be nice on the TTN server
}
APP_FreqPlan_Tasks();
switch(APP_FreqPlan_State())
{ // REVIEW: don't check internal state, but via test function
case APP_FREQPLAN_DONE:
_changeState(STATE_START_LORA_MODULE);
break;
case APP_FREQPLAN_FAILURE:
case APP_FREQPLAN_SERVER_BUSY:
SYS_PRINT("\r\nCNFG: Server busy/failure, retry\r\n");
_changeState(STATE_DOWNLOAD_FREQPLAN);
break;
case APP_FREQPLAN_ERROR:
SYS_PRINT("\r\nCNFG: Downloading frequency plan failed\r\n");
ErrorMessageWarning_Set(ERROR_MESSAGE_WARNING_HTTP_COMMUNICATION_FAILURE_FREQPLAN);
_changeState(STATE_COMMUNICATION_ERROR);
break;
}
break;
case STATE_START_LORA_MODULE:
if(APP_LORA_GET_APP_STATE() ==
APP_LORA_POLL_UART) // REVIEW: don't check internal state, but via test function
{
_changeState(STATE_DONE);
}
case STATE_COMMUNICATION_ERROR:
break;
case STATE_DONE:
break;
}
}
