/** @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;
}
