/** @brief Check the current coordinate * * @par * This is what triggers the geofence system. Everytime we get a fix we need to check if we are violating any geofences. * * @return void */ static void CheckCoord(void) { UINT8 current_fence_stat; int fence_num; adl_rtcTimeStamp_t TimeStamp0, TimeStamp1; adl_rtcTimeStamp_t DeltaTimeStamp; // If we are in dog walk mode, if (GetDogWalkMode() == DOGWALK_ENABLED) { DumpMessage("Dog walk mode\r\n"); return; } GetConvertTime(&TimeStamp0); current_fence_stat = eval_fix(&fence_num, GPS_FIX_REASON); GetConvertTime(&TimeStamp1); wm_sprintf(g_traceBuf, "Fence Number = %d\r\n", fence_num); DumpMessage(g_traceBuf); if (adl_rtcDiffTime(&TimeStamp1, &TimeStamp0, &DeltaTimeStamp) < 0) { DisplayErrorCode("adl_rtcConvertTime", __FILE__, __LINE__, -1); } wm_sprintf(g_traceBuf, "Calc time %d:%d\r\n", (int )DeltaTimeStamp.TimeStamp, (int)ADL_RTC_GET_TIMESTAMP_MS(DeltaTimeStamp)); DumpMessage(g_traceBuf); wm_sprintf(g_traceBuf, "current_fence_stat = %c\r\n", current_fence_stat); DumpMessage(g_traceBuf); }
void CgiResponseHandler::SendError(MgException* e) { MG_TRY() STRING shortError = e->GetExceptionMessage(); STRING stackTrace = e->GetStackTrace(); STRING statusMessage = e->GetClassName(); STRING longError = e->GetDetails(); //TODO: Use a string resource for html error text format printf(MapAgentStrings::StatusHeader, 559, MG_WCHAR_TO_CHAR(statusMessage)); printf(MapAgentStrings::ContentTypeHeader, MapAgentStrings::TextHtml, MapAgentStrings::Utf8Text); printf("\r\n" "<html>\n<head>\n" "<title>%s</title>\n" "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\n" "</head>\n" "<body>\n<h2>%s</h2>\n%s\n</body>\n</html>\n", MG_WCHAR_TO_CHAR(statusMessage), MG_WCHAR_TO_CHAR(shortError), MG_WCHAR_TO_CHAR(stackTrace)); DumpMessage(MG_WCHAR_TO_CHAR(longError)); MG_CATCH(L"CgiResponseHandler.SendError") }
// Fallback handler which handles any messages not handled by an actor. // This is a 'blind' handler which takes the unhandled message as raw data. void Handle( const void *const data, const Theron::uint32_t size, const Theron::Address from) { DumpMessage(data, size, from); }
void Initialize() { char* path = getenv(MapAgentStrings::PhysicalPath); if (NULL != path && strlen(path) > 0) { gConfigPath = MgUtil::MultiByteToWideChar(string(path)); } else { #if defined _WIN32 // IIS 6.0 does not honour APPL_PHYSICAL_PATH. Use exe path. wchar_t modPath[_MAX_PATH+1]; memset(modPath, 0, sizeof(wchar_t)*(_MAX_PATH+1)); if (GetModuleFileName(NULL, modPath, _MAX_PATH) > 4) { wchar_t* lastSlash = wcsrchr(modPath, L'\\'); if (NULL == lastSlash) { lastSlash = wcsrchr(modPath, L'/'); } if (NULL != lastSlash) { lastSlash++; *lastSlash = L'\0'; if (NULL != wcsstr(modPath, L"\\\\?\\")) { // skip past '\\?\' at front of string. gConfigPath = &(modPath[4]); } else { gConfigPath = modPath; } } } #endif } STRING configFile = gConfigPath; configFile.append(MapAgentStrings::WebConfig); string pathName = MgUtil::WideCharToMultiByte(configFile); DumpMessage("Loading configuration file: %s",pathName.c_str()); MG_TRY() MgInitializeWebTier(configFile); MG_CATCH_AND_THROW(L"FastCgiAgent.Initialize"); }
void GSM_DumpMessageLevel2_Text(GSM_StateMachine *s, unsigned const char *message, int messagesize, int type, const char *text) { GSM_Debug_Info *curdi; curdi = GSM_GetDI(s); if (curdi->dl == DL_TEXT || curdi->dl == DL_TEXTALL || curdi->dl == DL_TEXTDATE || curdi->dl == DL_TEXTALLDATE) { smprintf(s, "%s", text); smprintf(s, "type 0x%02X/length 0x%02X/%i", type, messagesize, messagesize); DumpMessage(curdi, message, messagesize); } }
FRAME_DBPROXY_NAMESPACE_BEGIN int32_t CFromRoomAddEvent:: OnMessage_AddBlacklist(MessageHeadSS * pMsgHead, IMsgBody* pMsgBody, const uint16_t nOptionLen, const void *pOptionData ) { if(pMsgHead == NULL || pMsgBody == NULL) { WRITE_ERROR_LOG("null pointer: roomserver add black list!{pMsgHead=0x%08X, pMsgBody=0x%08X}\n", pMsgHead, pMsgBody); return E_NULLPOINTER; } int32_t ret = S_OK; // int32_t threadindex = 需要获取线程ID CAddPlayerToBlackReq* pTmpBody = dynamic_cast<CAddPlayerToBlackReq*>(pMsgBody); if(pTmpBody == NULL) { WRITE_ERROR_LOG("get msg body failed!"); return E_NULLPOINTER; } CAddPlayerToBlackResp set_rolerank; MessageHeadSS resphead; ObtainRespHead(pMsgHead, resphead,MSGID_DBRS_ADD_BLACK_RESP); set_rolerank.nResult = S_OK; g_Frame.PostMessage(&resphead, &set_rolerank, nOptionLen, (const char*)pOptionData); DumpMessage("", &resphead, &set_rolerank, nOptionLen, (const char*)pOptionData); //时间类 CDateTime dt = CDateTime::CurrentDateTime(); char szDateTime[enmMaxTimeStringLength] = {0}; dt.ToDateTimeString(szDateTime); ret = InsertPlayerIntoRoomBlackList(pTmpBody->nRoleID, pTmpBody->nRoomID, szDateTime, pMsgHead->nRoleID); if(0 > ret) { WRITE_ERROR_LOG("Error: process roomserver add black list request failed! errorcode=0x%08X\n", ret); return ret; } WRITE_DEBUG_LOG( "process roomserver add black success! \n"); return S_OK; }
void CgiResponseHandler::SendResponse(MgHttpResponse* response) { MG_TRY() Ptr<MgHttpResult> result = response->GetResult(); STATUS status = result->GetStatusCode(); if (status != 200) { STRING statusMessage = result->GetHttpStatusMessage(); if (statusMessage == MapAgentStrings::FailedAuth1 || statusMessage == MapAgentStrings::FailedAuth2) { RequestAuth(); } else { //TODO: Use a resource for the HTML error message STRING shortError = result->GetErrorMessage(); STRING longError = result->GetDetailedErrorMessage(); printf(MapAgentStrings::StatusHeader, status, MG_WCHAR_TO_CHAR(statusMessage)); printf(MapAgentStrings::ContentTypeHeader, MapAgentStrings::TextHtml, ""); printf("\r\n" "<html>\n<head>\n" "<title>%s</title>\n" "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\n" "</head>\n" "<body>\n<h2>%s</h2>\n%s\n</body>\n</html>\n", MG_WCHAR_TO_CHAR(statusMessage), MG_WCHAR_TO_CHAR(shortError), MG_WCHAR_TO_CHAR(longError)); DumpMessage(MG_WCHAR_TO_CHAR(longError)); } } else { DumpMessage(MapAgentStrings::StatusOkHeader); // Status was ok. Send the real result back. STRING contentType = result->GetResultContentType(); STRING stringVal; printf(MapAgentStrings::StatusOkHeader); if (contentType.length() > 0) { // If we are returning text, state that it is utf-8. string charSet = ""; if (contentType.find(L"text") != contentType.npos) //NOXLATE { charSet = MapAgentStrings::Utf8Text; } printf(MapAgentStrings::ContentTypeHeader, MG_WCHAR_TO_CHAR(contentType), charSet.c_str()); } else { printf(MapAgentStrings::ContentTypeHeader, MapAgentStrings::TextPlain, MapAgentStrings::Utf8Text); } Ptr<MgByteReader> outputReader; Ptr<MgDisposable> resultObj = result->GetResultObject(); MgDisposable* pResultObj = (MgDisposable*)resultObj; if (NULL != dynamic_cast<MgByteReader*>(pResultObj)) { outputReader = (MgByteReader*) SAFE_ADDREF(pResultObj); } else if (NULL != dynamic_cast<MgStringCollection*>(pResultObj)) { outputReader = ((MgStringCollection*)pResultObj)->ToXml(); } else if (NULL != dynamic_cast<MgSpatialContextReader*>(pResultObj)) { outputReader = ((MgSpatialContextReader*)pResultObj)->ToXml(); } else if (NULL != dynamic_cast<MgLongTransactionReader*>(pResultObj)) { outputReader = ((MgLongTransactionReader*)pResultObj)->ToXml(); } else if (NULL != dynamic_cast<MgHttpPrimitiveValue*>(pResultObj)) { stringVal = ((MgHttpPrimitiveValue*)pResultObj)->ToString(); } if (stringVal.length() > 0) { string utf8 = MG_WCHAR_TO_CHAR(stringVal); printf(MapAgentStrings::ContentLengthHeader, utf8.length()); printf("\r\n%s",utf8.c_str()); } else if (outputReader != NULL) { Ptr<MgHttpHeader> respHeader = response->GetHeader(); //Check for chunking hint if (respHeader->GetHeaderValue(MgHttpResourceStrings::hrhnTransfer_Encoding) == MgHttpResourceStrings::hrhnChunked) { CgiReaderStreamer crs(outputReader); crs.StreamResult(); } else { INT64 outLen = outputReader->GetLength(); printf(MapAgentStrings::ContentLengthHeader,(INT32)outLen); printf("\r\n"); unsigned char buf[4096]; int nBytes = outputReader->Read(buf,4096); while (nBytes > 0) { fwrite(buf, 1, nBytes, stdout); nBytes = outputReader->Read(buf,4096); } } } else { printf(MapAgentStrings::ContentLengthHeader, 0); printf("\r\n"); } } MG_CATCH_AND_THROW(L"CgiResponseHandler.SendResponse"); }
void Session::Start() { if(setCount != 2) throw "not ready"; char buf[MSGLEN] = {4, 0, 0, 0}; char caption[256] = ""; int rsize; int nfds; sprintf(caption, "%03d:send_prim", id); DumpMessage(caption, buf); write(fds[0], buf, sizeof(buf)); buf[1] = 1; sprintf(caption, "%03d:send_seco", id); DumpMessage(caption, buf); write(fds[1], buf, sizeof(buf)); fd_set tempfds, readfds; FD_ZERO(&tempfds); FD_SET(fds[0], &tempfds); FD_SET(fds[1], &tempfds); nfds = (fds[0] > fds[1] ? fds[0] : fds[1]) + 1; while(1) { memcpy(&readfds, &tempfds, sizeof(fd_set)); select(nfds, &readfds, NULL, NULL, 0); if(FD_ISSET(fds[0], &readfds)) { rsize = recv(fds[0], buf, sizeof(buf), 0); if(0 == rsize) { break; } else if(-1 == rsize) { perror("recv"); break; } else { sprintf(caption, "%03d:send_to_1", id); DumpMessage(caption, buf); DumpUsername(0, buf); write(fds[1], buf, rsize); } } if(FD_ISSET(fds[1], &readfds)) { rsize = recv(fds[1], buf, sizeof(buf), 0); if(0 == rsize) { break; } else if(-1 == rsize) { perror("recv"); break; } else { sprintf(caption, "%03d:send_to_0", id); DumpMessage(caption, buf); DumpUsername(1, buf); write(fds[0], buf, rsize); } } } close(fds[0]); close(fds[1]); return; }
/** @brief callback method for +CSQ unsolicted messages * * @par * Handler function which handles the +CSQ indicaiton. * This handler provides the signal strength. * * @param paras * * @return FALSE */ bool CSQHandler(adl_atUnsolicited_t *paras) { ascii rssi[10]; int rssi_int; static char GSMAlarmGenerated = 0; wm_strGetParameterString(rssi, paras->StrData, 1); rssi_int = atoi(rssi); // rssi has a range from 0 - 31. // we have 6 ranges. Use the defines to define the 0-5 signal. if (rssi_int < RSSI_0) { g_status.GSMSignalStrength = '0'; } else if (rssi_int < RSSI_1) { g_status.GSMSignalStrength = '1'; } else if (rssi_int < RSSI_2) { g_status.GSMSignalStrength = '2'; } else if (rssi_int < RSSI_3) { g_status.GSMSignalStrength = '3'; } else if (rssi_int < RSSI_4) { g_status.GSMSignalStrength = '4'; } else if (rssi_int == RSSI_ERROR) { g_status.GSMSignalStrength = '0'; } else { g_status.GSMSignalStrength = '5'; } wm_sprintf(g_traceBuf, "Sig strength = %c\r\n", g_status.GSMSignalStrength); DumpMessage(g_traceBuf); if (g_config.GSMAlertThresh != 'N') { if ((g_status.GSMSignalStrength <= g_config.GSMAlertThresh) && !GSMAlarmGenerated) { g_status.GSMAlarm = 'Y'; GSMAlarmGenerated = 1; alarm_suppress_set_alarm_time(GSM_ALARM_SUP); } else if ((g_status.GSMSignalStrength > g_config.GSMAlertThresh) && (alarm_suppress_status(GSM_ALARM_SUP) == ALARM_EXPIRED)) { GSMAlarmGenerated = 0; } } else { GSMAlarmGenerated = 0; } return FALSE; }
// Main execution loop. This loop executes correctly when run both as a // standard Cgi app and when running as a FastCgi process. This loop is // single threaded. Multiple FastCgi processes are started to handle // concurrent incoming requests. int main () { #ifdef _WIN32 _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); #ifdef _DEBUG // to debug memory leaks, set a breakpoint here and set iBlock // to the block allocation you want to break on long iBlock = -1; _CrtSetBreakAlloc(iBlock); #endif #endif bool bFirstTime = true; int nRequests = 1; INT32 dbgPause = 0; CgiPostParser postParser; MG_TRY() // If Web Tier generates an exception which is not caught // by the HTTP handler execute, we should exit to reduce // the likelihood of a hung agent lying around. if (bFirstTime) { bFirstTime = false; #ifdef _WIN32 // Set stdin and stdout to binary mode _setmode(0, _O_BINARY); _setmode(1, _O_BINARY); #else //TODO: Does this need to be done under Linux? #endif //Debugging code //EchoTest(); //break; Initialize(); #ifdef _DEBUG MgConfiguration* cfg = MgConfiguration::GetInstance(); cfg->GetIntValue(MgConfigProperties::AgentPropertiesSection, MgConfigProperties::AgentDebugPause, dbgPause, MgConfigProperties::DefaultAgentDebugPause); #endif DumpMessage("Initialized process %d",getpid()); } DumpMessage("Process %d servicing request #%d",getpid(), nRequests); // Construct self Url. It is embedded into the output stream // of some requests (like GetMap). Use a fully qualified URL. char* serverName = getenv(MapAgentStrings::ServerName); char* serverPort = getenv(MapAgentStrings::ServerPort); char* scriptName = getenv(MapAgentStrings::ScriptName); char* remoteAddr = getenv(MapAgentStrings::RemoteAddr); char* httpClientIp = getenv(MapAgentStrings::HttpClientIp); char* httpXFF = getenv(MapAgentStrings::HttpXForwardedFor); char* secure = getenv(MapAgentStrings::Secure); string url = secure != NULL && (!_stricmp(secure, "on") || !_stricmp(secure, "true")) ? MapAgentStrings::Https : MapAgentStrings::Http; // NOXLATE if (NULL != serverName && NULL != serverPort && NULL != scriptName) { url.append(serverName); url += ':'; url.append(serverPort); url.append(scriptName); } STRING wUrl = MgUtil::MultiByteToWideChar(url); Ptr<MgHttpRequest> request = new MgHttpRequest(wUrl); Ptr<MgHttpRequestParam> params = request->GetRequestParam(); // Temporarily moved here to allow debugging post. #ifdef _DEBUG if(dbgPause > 0) { DumpMessage("Delaying request %d seconds", dbgPause); #ifdef _WIN32 Sleep(dbgPause * 1000L); #else struct timespec delay = { (time_t)dbgPause, 0 }; nanosleep(&delay, NULL); #endif } #endif // Parse inputs GET/POST char* query = getenv(MapAgentStrings::QueryString); char* requestMethod = getenv(MapAgentStrings::RequestMethod); if (NULL != requestMethod && NULL != strstr(requestMethod, "POST")) { // Must be a POST request postParser.Parse(params); } else if (NULL != query && strlen(query) > 0) { DumpMessage2("Query string present"); DumpMessage2(query); // If we have a QUERY_STRING then we are a GET request MapAgentGetParser::Parse(query, params); } // check for CLIENTIP, if it's not there (and it shouldn't be), // add it in using httpClientIp. httpXFF or remoteAddr STRING clientIp = L""; if (!params->ContainsParameter(L"CLIENTIP")) // NOXLATE { if (NULL != httpClientIp && strlen(httpClientIp) > 0 && _stricmp(httpClientIp, MapAgentStrings::Unknown) != 0) { clientIp = MgUtil::MultiByteToWideChar(httpClientIp); params->AddParameter(L"CLIENTIP", clientIp); // NOXLATE } else if (NULL != httpXFF && strlen(httpXFF) > 0 && _stricmp(httpXFF, MapAgentStrings::Unknown) != 0) { clientIp = MgUtil::MultiByteToWideChar(httpXFF); params->AddParameter(L"CLIENTIP", clientIp); // NOXLATE } else if (NULL != remoteAddr && strlen(remoteAddr) > 0) { clientIp = MgUtil::MultiByteToWideChar(remoteAddr); params->AddParameter(L"CLIENTIP", clientIp); // NOXLATE } } // Check for HTTP Basic Auth header char* auth = getenv(MapAgentStrings::HttpAuth); bool gotAuth = ParseAuth(auth, params); if (!gotAuth) { // And check for a REMOTE_USER remapped header auth = getenv(MapAgentStrings::HttpRemoteUser); gotAuth = ParseAuth(auth, params); } // Log request information string postData = ""; if (requestMethod && _stricmp(requestMethod, "POST") == 0) // NOXLATE { // Get the post xml data postData = params->GetXmlPostData(); } STRING client = params->GetParameterValue(MgHttpResourceStrings::reqClientAgent); string strRequestMethod= std::string(requestMethod); string strQuery = std::string(query); LogRequest(client, clientIp, url, strRequestMethod, postData, strQuery); Ptr<MgPropertyCollection> paramList = params->GetParameters()->GetPropertyCollection(); if (paramList != NULL) { //Check to be sure that we have some kind of credentials before continuing. Either //username/password or sessionid. bool bValid = paramList->Contains(MgHttpResourceStrings::reqSession); // Strike two: no session? how about a username? if (!bValid) bValid = paramList->Contains(MgHttpResourceStrings::reqUsername); // Strike three: no username either? How about if it's an XML POST if (!bValid) bValid = params->GetXmlPostData().length() != 0; // Certain operations do not require authentication STRING operation = params->GetParameterValue(L"OPERATION"); if((_wcsicmp(operation.c_str(), L"GETSITESTATUS") == 0)) { bValid = true; } if (!bValid) { // Invalid authentication information is not fatal, we should continue. CgiResponseHandler::RequestAuth(); // clean up any temporary files we created MapAgentCommon::DeleteTempFiles(params); return 0; } Ptr<MgHttpResponse> response = request->Execute(); // NOTE: temporary files are deleted when we execute the request CgiResponseHandler::SendResponse(response); } MG_CATCH(L"FastCgiAgent.main"); if (mgException != NULL) { CgiResponseHandler::SendError(mgException); } DumpMessage("Process %d serviced request #%d",getpid(), nRequests++); MgUninitializeWebTier(); DumpMessage("Exiting process %d",getpid()); return 0; }
void DisplayGPSStates(void) { ascii TxString[100]; memset(TxString, '\0', sizeof(TxString)); switch (gps_state) { case GPS_OFF: DumpMessage("GPS STATE = GPS_OFF\r\n"); strcpy(TxString, "GPS STATE = GPS_OFF\r\n"); //if(enable_ota38) send_ota_response("GPS STATE = GPS_OFF\r\n"); break; case GPS_START: DumpMessage("GPS STATE = GPS_START\r\n"); strcpy(TxString, "GPS STATE = GPS_START\r\n"); //if(enable_ota38) send_ota_response("GPS STATE = GPS_START\r\n"); break; case GPS_GET_FIX: DumpMessage("GPS STATE = GPS_GET_FIX\r\n"); strcpy(TxString, "GPS STATE = GPS_GET_FIX\r\n"); //if(enable_ota38) send_ota_response("GPS STATE = GPS_GET_FIX\r\n"); break; case GPS_PROC_FIX: DumpMessage("GPS STATE = GPS_PROC_FIX\r\n"); strcpy(TxString, "GPS STATE = GPS_PROC_FIX\r\n"); //if(enable_ota38) send_ota_response("GPS STATE = GPS_PROC_FIX\r\n"); break; case GPS_WAIT_NEXT_FIX: DumpMessage("GPS STATE = WAIT_NEXT_FIX\r\n"); strcpy(TxString, "GPS STATE = WAIT_NEXT_FIX\r\n"); //if(enable_ota38) send_ota_response("GPS STATE = WAIT_NEXT_FIX\r\n"); break; } switch (TrackingMode) { case TRACKING_MODE_OFF: DumpMessage("Tracking Mode = TRACKING_MODE_OFF\r\n"); strcat(TxString, "Tracking Mode = TRACKING_MODE_OFF\r\n"); //if(enable_ota38) send_ota_response("Tracking Mode = TRACKING_MODE_OFF\r\n"); break; case ACCEL_TRIG_TRACKING_MODE: DumpMessage("Tracking Mode = ACCEL_TRIG_TRACKING_MODE\r\n"); strcat(TxString, "Tracking Mode = ACCEL_TRIG_TRACKING_MODE\r\n"); //if(enable_ota38) send_ota_response("Tracking Mode = ACCEL_TRIG_TRACKING_MODE\r\n"); break; case SERVER_TRIG_TRACKING_MODE: DumpMessage("Tracking Mode = SERVER_TRIG_TRACKING_MODE\r\n"); strcat(TxString, "Tracking Mode = SERVER_TRIG_TRACKING_MODE\r\n"); //if(enable_ota38) send_ota_response("Tracking Mode = SERVER_TRIG_TRACKING_MODE\r\n"); break; case DOG_PARK_TRACKING_MODE: DumpMessage("Tracking Mode = DOG_PARK_TRACKING_MODE\r\n"); strcat(TxString, "Tracking Mode = DOG_PARK_TRACKING_MODE\r\n"); //if(enable_ota38) send_ota_response("Tracking Mode = DOG_PARK_TRACKING_MODE\r\n"); break; case TIMED_WAKE_TRACKING_MODE: DumpMessage("Tracking Mode = TIMED_WAKE_TRACKING_MODE\r\n"); strcat(TxString, "Tracking Mode = TIMED_WAKE_TRACKING_MODE\r\n"); //if(enable_ota38) send_ota_response("Tracking Mode = TIMED_WAKE_TRACKING_MODE\r\n"); break; default: DumpMessage("UNKNOWN TRACKING MODE\r\n"); strcat(TxString, "UNKNOWN TRACKING MODE\r\n"); //if(enable_ota38) send_ota_response("UNKNOWN TRACKING MODE\r\n"); } //Send response over the air.. if(enable_ota38) send_ota_response(TxString); }
/** @brief Process the GPS fix * * @return void */ static void ProcFix(FIX_QUALITY fix_quality) { int sv, strong, weak; ascii buffer[8]; ascii satBuf[1]; double SpeedMPH = 0.0; static u8 OverSpeedAlarmGenerated = 0; adl_rtcTimeStamp_t GPSTimeStamp; adl_rtcTime_t GPSTime; static bool RTC_Update = 1; s32 sReturn=0; DumpMessage("processing proc fix\n\r"); if ((TrackingMode == DOG_PARK_TRACKING_MODE) && FirstDogParkFix) { g_DogParkFence.posts[0].lat_32 = g_GGAInfo.Latitude; g_DogParkFence.posts[0].long_32 = g_GGAInfo.Longitude; // these are "dummy" posts since we only support >=2. // The dog park radius is handled in fence.c g_DogParkFence.posts[1].lat_32 = g_GGAInfo.Latitude; g_DogParkFence.posts[1].long_32 = g_GGAInfo.Longitude; Config_SetMode(DOG_PARK_MODE, 0, &g_DogParkFence, TRUE); // TODO add dog park fence. FirstDogParkFix = 0; } g_current_fix_32.lat_32 = g_GGAInfo.Latitude; g_current_fix_32.long_32 = g_GGAInfo.Longitude; // Signal strength. GetSV_SRN(&sv, &strong, &weak); g_status.GPSSignalStrength1 = '0' + strong; g_status.GPSSignalStrength2 = '0' + weak; wm_sprintf(g_traceBuf, "sig strong = %c sig weak = %c\r\n", g_status.GPSSignalStrength1, g_status.GPSSignalStrength2); DumpMessage(g_traceBuf); // Time. wm_itohexa((ascii *)&buffer, g_GGAInfo.Time, 8); memcpy(&g_current_fix.utc, &buffer, 8); if(RTC_Update == 1 && fix_quality == FIX_3D) { //Update RTC with GPS time only once on power up GPSTimeStamp.TimeStamp = g_GGAInfo.Time; GPSTimeStamp.SecondFracPart = 0; if ((sReturn = adl_rtcConvertTime(&GPSTime, &GPSTimeStamp, ADL_RTC_CONVERT_FROM_TIMESTAMP)) < 0) { DisplayErrorCode("adl_rtcConvertTime", __FILE__, __LINE__, sReturn); } if(adl_rtcSetTime(&GPSTime) != OK) DumpMessage("Error setting RTC time\r\n"); else { //Restart accelerometer timer, to avoid sudden slow idle mode, due to change in RTC time. //If RTC time jumps up suddenly and if the diff compared to old RTC is more than accel sleep duration, then //the device can enter slow idle mode immediately in Track Mode and Low Power full track mode. ActivateAccelOnPowerUp(); wm_sprintf(g_traceBuf,"RTC time udpated with GPS value : 0x%x\r\n",(unsigned int)GPSTimeStamp.TimeStamp); DumpMessage(g_traceBuf); DumpMessageUSB(g_traceBuf,1); } RTC_Update = 0; } // Number of sats wm_itohexa((ascii *)&satBuf, g_GGAInfo.NumberOfSatillites, 1); memcpy(&g_status.NumBirds, &satBuf, 1); // lat and long wm_itohexa((ascii *)&buffer, g_GGAInfo.Latitude, 8); memcpy(&g_current_fix.lat, &buffer, 8); wm_itohexa((ascii *)&buffer, g_GGAInfo.Longitude, 8); memcpy(&g_current_fix.longi, &buffer, 8); // copy HDOP to where EPE used to be. wm_itohexa((ascii *)&buffer, g_GGAInfo.HDOP, 2); memcpy(&g_current_fix.epe, &buffer, 2); wm_sprintf(g_traceBuf, "HDOP: %c%c\r\n", buffer[1], buffer[0]); DumpMessage(g_traceBuf); // check the speed. The speed from VTGInfo is in km/hr // the speed from the config struct is in miles/hr SpeedMPH = (double)g_VTGInfo.Speed * KM_IN_MILES / METERS_IN_KM; if (!OverSpeedAlarmGenerated && (SpeedMPH >= (double)g_config.OverSpeedAlertThresh) && (g_config.OverSpeedAlertThresh != 0)) { DumpMessage("over speed alarm detected\n\r"); g_status.OverSpeedAlarm = 'Y'; OverSpeedAlarmGenerated = 1; } else if (SpeedMPH < (double)g_config.OverSpeedAlertThresh) { DumpMessage("over speed alarm NOT detected\n\r"); g_status.OverSpeedAlarm = 'N'; OverSpeedAlarmGenerated = 0; } // write the waypoint fix to serial flash. WriteWaypointFromFix(&g_current_fix, g_VTGInfo.Speed, g_VTGInfo.Course, fix_quality); // do not check on the first dog park fix. DumpMessage("\r\nCheckCoords\r\n"); if (((!FirstDogParkFix) && (TrackingMode == DOG_PARK_TRACKING_MODE)) || (TrackingMode != DOG_PARK_TRACKING_MODE)) { CheckCoord(); } }
void NextFixHandler(u8 timerid, void *context) { (void)timerid; (void)context; s32 sReturn = -1; char prevGPSstat; adl_rtcTimeStamp_t CurrentTimeStamp; adl_rtcTimeStamp_t DeltaTimeStamp; TCP_STATUS status; static BOOL AGPSRequested=0; static u8 Count=0; //Count of how many times this function was entered. int ret_val; prevGPSstat = g_status.GPSStatus; TRACE((1, "Next GPS Fix timer triggered")); // control the tracking mode state. Process the tracking mode // requests from the rest of the system. switch (TrackingMode) { case TRACKING_MODE_OFF: if (GetDogParkMode() == DOGPARK_ENABLED) { TrackingMode = DOG_PARK_TRACKING_MODE; } else if (AccelTrackingReq == TRACKING_MODE_REQ_ACTIVE) { TrackingMode = ACCEL_TRIG_TRACKING_MODE; } else if (TimedWakeupTrackingReq == TRACKING_MODE_REQ_ACTIVE) { TrackingMode = TIMED_WAKE_TRACKING_MODE; } else { TrackingMode = TRACKING_MODE_OFF; } break; case ACCEL_TRIG_TRACKING_MODE: if (GetDogParkMode() == DOGPARK_ENABLED) { TrackingMode = DOG_PARK_TRACKING_MODE; } else if (AccelTrackingReq == TRACKING_MODE_REQ_RELEASE) { TrackingMode = TRACKING_MODE_OFF; } else { TrackingMode = ACCEL_TRIG_TRACKING_MODE; } break; case DOG_PARK_TRACKING_MODE: if (GetDogParkMode() == DOGPARK_DISABLED) { TrackingMode = TRACKING_MODE_OFF; } else { TrackingMode = DOG_PARK_TRACKING_MODE; } break; case TIMED_WAKE_TRACKING_MODE: if (TimedWakeupTrackingReq == TRACKING_MODE_REQ_RELEASE) { TrackingMode = TRACKING_MODE_OFF; } else { TrackingMode = TIMED_WAKE_TRACKING_MODE; } break; default: DumpMessage("Undefined tracking mode\r\n"); TrackingMode = TRACKING_MODE_OFF; break; } switch (gps_state) { // the GPS should be in OFF mode while in this state. case GPS_OFF: if ((TrackingMode == ACCEL_TRIG_TRACKING_MODE) || (TrackingMode == DOG_PARK_TRACKING_MODE) || (TrackingMode == TIMED_WAKE_TRACKING_MODE)) { GetConvertTime(&TrackTimeStamp); gps_state = GPS_START; DumpMessage("GPS START!\r\n"); //Reset the flag AGPSRequested = 0; } else { gps_state = GPS_OFF; } break; // attempt to start up the GPS. case GPS_START: gps_Start(); if (!HadFix && !AttemptedAGPSNoFix) { DumpMessage("Never had fix. Going to use AGPS!\r\n"); //performAGPS(0.0, 0.0, 0.0, 0.0); AttemptedAGPSNoFix = 1; } else if (HadFix) { GetConvertTime(&CurrentTimeStamp); //Request AGPS is last fix is more than 2 hrs old. if((CurrentTimeStamp.TimeStamp - g_AGPSData.LastReqTimeStamp) >= 2*60*60) { AGPSRequested = 0; wm_sprintf(g_traceBuf,"g_AGPSData.LastReqTimeStamp : 0x%x, CurrentTimeStamp: 0x%x\r\n",(unsigned int)g_AGPSData.LastReqTimeStamp,(unsigned int)CurrentTimeStamp.TimeStamp); DumpMessage(g_traceBuf); DumpMessageUSB(g_traceBuf,1); DumpMessage("AGPS data is old. Request fresh data\r\n"); } // if (adl_rtcDiffTime(&CurrentTimeStamp, &FixTimeStamp, &DeltaTimeStamp) < 0) // { // DisplayErrorCode("adl_rtcConvertTime", __FILE__, __LINE__, sReturn); // } // else // { // wm_sprintf(g_traceBuf,"FixTimeStamp : 0x%x, CurrentTimeStamp: 0x%x\r\n",(unsigned int)FixTimeStamp.TimeStamp,(unsigned int)CurrentTimeStamp.TimeStamp); // DumpMessage(g_traceBuf); // DumpMessageUSB(g_traceBuf,1); //if (DeltaTimeStamp.TimeStamp >= 60 * 60 * 2) //{ // DumpMessage("Over two hours since last fix, going to use AGPS!\r\n"); // performAGPS(0.0, 0.0, 0.0, 0.0); //} //} } gps_state = GPS_GET_FIX; DumpMessage("GET FIX!\r\n"); //} break; // keep on the GPS until we get a fix. probably add a timeout to this... case GPS_GET_FIX: //Increment the count to keep a track of how many times this state was entered. Count++; // if tracking mode has been disabled... if (TrackingMode == TRACKING_MODE_OFF) { gps_state = GPS_OFF; break; } GetGGAInfo(&g_GGAInfo); GetVGTInfo(&g_VTGInfo); //Request AGPS GetTCPStatus(&status); if(!AGPSRequested && status == TCP_CONNECT) { //Get the current time GetConvertTime(&CurrentTimeStamp); //Compare the times. if((CurrentTimeStamp.TimeStamp - g_AGPSData.LastReqTimeStamp) < 2*60*60) //check for < 2 hours { wm_sprintf(g_traceBuf,"CurrentTimeStamp.TimeStamp: 0x%x, g_AGPSData.LastReqTimeStamp: 0x%x\r\n", (unsigned int)CurrentTimeStamp.TimeStamp,(unsigned int)g_AGPSData.LastReqTimeStamp); DumpMessage(g_traceBuf); DumpMessageUSB(g_traceBuf,1); //Send the last stored AGPS data to ublox directly. if ((ret_val = adl_fcmSendData(ubloxDataFcmHandle, (unsigned char *)g_AGPSData.AGPSData, g_AGPSData.datalen)) != OK) { wip_debug("ERROR: Could not send data to ublox device: %d\r\n", ret_val); wm_sprintf(g_traceBuf,"ERROR: Could not send data to ublox device: %d\r\n", ret_val); DumpMessageUSB(g_traceBuf,1); set_agps_status(AGPS_NOT_USED); } else { AGPSRequested = 1; wm_sprintf(g_traceBuf,"AGPS data sent to ublox (<2 hrs case): %ld bytes\r\n", g_AGPSData.datalen); DumpMessage(g_traceBuf); DumpMessageUSB(g_traceBuf,1); } } } // Check if we got a fix. if (g_GGAInfo.FixQuality == FIX_3D) { SetFixStatus(HAD_3D_FIX); alarmGenerated = 0; GetConvertTime(&FixTimeStamp); gps_state = GPS_PROC_FIX; if (g_config.WaypointInterval >= GPS_WAYPOINT_SHUTDOWN_INTERVAL) { gps_Stop(); } // GPS working //g_status.GPSStatus = 'W'; // clear alarm if (alarm_suppress_status(GPS_ALARM_SUP) == ALARM_EXPIRED) { g_status.GPSAlarm = 'N'; GPSAlarmGenerated = 0; } gps_state = GPS_PROC_FIX; DumpMessage("GPS_PROC_FIX\r\n"); } else { if (g_GGAInfo.FixQuality == FIX_2D) { DumpMessage("GOT 2D FIX -- will not use\r\n"); if(status == TCP_CONNECT && !AGPSRequested) { //Request AGPS with available 2D fix performAGPS((g_GGAInfo.Latitude/1000000.0), (g_GGAInfo.Longitude/1000000.0), 0.0, 0.0); AGPSRequested = 1; } } else //this fucntion is called once every 925ms. so 16*925 = 15 secs { //Check for the validity of WaitTimeout if(g_AGPSData.WaitTimeout == 0 || g_AGPSData.WaitTimeout > 99) g_AGPSData.WaitTimeout = 15; //Default to 15 if found out of range //If 2D fix not received in 15 secs then request AGPS with last valid 3D fix. //Request AGPS with last GPS fix if(Count > g_AGPSData.WaitTimeout && status == TCP_CONNECT && !AGPSRequested ) { DumpMessage("Request fresh AGPS data\r\n"); performAGPS(0.0, 0.0, 0.0, 0.0); AGPSRequested = 1; Count=0; } } g_status.GPSStatus = 'N'; if (prevGPSstat == 'W') { TRACE((1, "Lost GPS Signal")); } gps_state = GPS_GET_FIX; } break; case GPS_PROC_FIX: ProcFix(FIX_3D); // GPS working g_status.GPSStatus = 'W'; DumpMessage("Got a fix1\r\n"); adl_atSendResponsePort(ADL_AT_RSP, ADL_PORT_USB, "***GOT_FIX***\r\n"); gps_state = GPS_WAIT_NEXT_FIX; HadFix = 1; break; case GPS_WAIT_NEXT_FIX: DumpMessage("GPS_WAIT_NEXT_FIX\r\n"); GetConvertTime(&CurrentTimeStamp); // time difference between last fix and current time. if (adl_rtcDiffTime(&CurrentTimeStamp, &FixTimeStamp, &DeltaTimeStamp) < 0) { DisplayErrorCode("adl_rtcConvertTime", __FILE__, __LINE__, sReturn); } // If the tracking interval time has elapsed, // go and get another fix or if the trackind mode contoller has disabled tracking, // go into the off state. if (DeltaTimeStamp.TimeStamp >= g_config.WaypointInterval) { wm_sprintf(g_traceBuf, "currenttimestamp = 0x%x fix time stamp = 0x%x delta time stamp = 0x%x waypoint interval = %d\r\n", (unsigned int )CurrentTimeStamp.TimeStamp, (unsigned int )FixTimeStamp.TimeStamp, (unsigned int )DeltaTimeStamp.TimeStamp, (int )g_config.WaypointInterval); DumpMessage(g_traceBuf); gps_state = GPS_START; } else { if (TrackingMode == TRACKING_MODE_OFF) { gps_Stop(); gps_state = GPS_OFF; FirstDogParkFix = 1; } else { gps_state = GPS_WAIT_NEXT_FIX; } } break; default: DumpMessage("Error: Unknown GPS state\r\n"); break; } }
GSM_Error GSM_DispatchMessage(GSM_StateMachine *s) { GSM_Error error = ERR_UNKNOWNFRAME; GSM_Protocol_Message *msg = s->Phone.Data.RequestMsg; GSM_Phone_Data *Phone = &s->Phone.Data; gboolean disp = FALSE; GSM_Reply_Function *Reply; int reply; GSM_DumpMessageLevel2Recv(s, msg->Buffer, msg->Length, msg->Type); GSM_DumpMessageLevel3Recv(s, msg->Buffer, msg->Length, msg->Type); Reply = s->User.UserReplyFunctions; if (Reply != NULL) { error = CheckReplyFunctions(s,Reply,&reply); } if (error == ERR_UNKNOWNFRAME) { Reply = s->Phone.Functions->ReplyFunctions; error = CheckReplyFunctions(s,Reply,&reply); } if (error==ERR_NONE) { error=Reply[reply].Function(msg, s); if (Reply[reply].requestID==Phone->RequestID) { if (error == ERR_NEEDANOTHERANSWER) { error = ERR_NONE; } else { Phone->RequestID=ID_None; } } } if (strcmp(s->Phone.Functions->models,"NAUTO")) { disp = TRUE; switch (error) { case ERR_UNKNOWNRESPONSE: smprintf_level(s, D_ERROR, "\nUNKNOWN response"); break; case ERR_UNKNOWNFRAME: smprintf_level(s, D_ERROR, "\nUNKNOWN frame"); break; case ERR_FRAMENOTREQUESTED: smprintf_level(s, D_ERROR, "\nFrame not request now"); break; default: disp = FALSE; } if (error == ERR_UNKNOWNFRAME || error == ERR_FRAMENOTREQUESTED) { error = ERR_TIMEOUT; } } if (disp) { smprintf(s,". Please report the error, see <http://wammu.eu/support/bugs/>. Thank you\n"); if (Phone->SentMsg != NULL) { smprintf(s,"LAST SENT frame "); smprintf(s, "type 0x%02X/length %ld", Phone->SentMsg->Type, (long)Phone->SentMsg->Length); DumpMessage(GSM_GetDI(s), Phone->SentMsg->Buffer, Phone->SentMsg->Length); } smprintf(s, "RECEIVED frame "); smprintf(s, "type 0x%02X/length 0x%lx/%ld", msg->Type, (long)msg->Length, (long)msg->Length); DumpMessage(GSM_GetDI(s), msg->Buffer, msg->Length); smprintf(s, "\n"); } return error; }