/** * Read thread to process messages from or to the GPRS modem */ static SIRF_PAL_OS_THREAD_DECL SIRF_GPRS_AT_COMMAND_ReadThread( SIRF_PAL_OS_THREAD_PARAMS ) { tSIRF_UINT32 wait_start; tSIRF_UINT32 wait_end; tSIRF_UINT32 wait_elapsed; tSIRF_UINT32 timeout; tSIRF_UINT32 result; tSIRF_UINT32 semaphore_result; SIRF_PAL_OS_THREAD_UNUSED; SIRF_PAL_OS_THREAD_START(); gprs_at_command.semaphore_timeout = SIRF_TIMEOUT_INFINITE; /*-------------------------------------------------------------------------*/ /* Main loop */ /*-------------------------------------------------------------------------*/ while ( gprs_at_command.thread_running ) { wait_start = SIRF_PAL_OS_TIME_SystemTime(); semaphore_result = SIRF_PAL_OS_SEMAPHORE_Wait(gprs_at_command.semaphore, gprs_at_command.semaphore_timeout); /* We just woke up. Check to see if we've been asked to exit */ if ( !gprs_at_command.thread_running ) { break; } /* Record how long we were waiting, just in case what we were looking * for did not arrive */ wait_end = SIRF_PAL_OS_TIME_SystemTime(); /* 32 bits of timer will roll over every ~50 days, but we need to be * safe */ if (wait_end >= wait_start) { wait_elapsed = wait_end - wait_start; } else { /* Roll over case */ tSIRF_UINT64 temp; temp = wait_end + ULONG_MAX + 1 - wait_start; /* This should now be less than 32 bits */ wait_elapsed = (tSIRF_UINT32) temp; } /* If we are in TCP Data mode process all of these messages */ if (GPRS_SERVER_STATE_TCP_IP_DATA == gprs_at_command.state) { result = process_next_msg( &gprs_at_command.listener[(tSIRF_UINT32)gprs_at_command.data_handle].msg_queue_mas, handle_mas_msg, &timeout); if (SIRF_SUCCESS != result) { /* really bad error occured here, send it to the listeners */ handle_unexpected_result(result); SIRF_PAL_OS_THREAD_Sleep(10); } /* For TCP Data the timeout values are either 0 or GPRS_DATA_TIMEOUT * as the data connection should be shut down if idle for the * GPRS_DATA_TIMEOUT amount. If a message was processed the timeout * value is set to 0 so that the next one can be processed */ else if (SIRF_TIMEOUT_INFINITE == timeout) { result = process_next_msg( &gprs_at_command.listener[(tSIRF_UINT32)gprs_at_command.data_handle].msg_queue_mas_input, handle_mas_input_msg, &timeout); if (SIRF_SUCCESS != result) { /* really bad error occured here, send it to the listeners */ handle_unexpected_result(result); SIRF_PAL_OS_THREAD_Sleep(10); } /* At this point check to see if the timeout has elapsed and we need * to transition from data to at command mode */ if (SIRF_SUCCESS != semaphore_result && wait_elapsed >= GPRS_DATA_TIMEOUT) { gprs_switch_from_data_mode(); gprs_at_command.semaphore_timeout = SIRF_TIMEOUT_INFINITE; } else { gprs_at_command.semaphore_timeout = GPRS_DATA_TIMEOUT; } } continue; } /* If we make it to this line of code the state is either * GPRS_SERVER_STATE_AT_COMMAND * GPRS_SERVER_STATE_AT_RESPONSE * * Handle responses and unsolicited messages next */ result = process_next_msg( &gprs_at_command.msg_queue_gprs, handle_gprs_msg, &timeout); if (SIRF_SUCCESS != result) { /* really bad error occured here, send it to the listeners */ handle_unexpected_result(result); SIRF_PAL_OS_THREAD_Sleep(10); continue; } /* SIRF_TIMEOUT_INFINITE means nothing was processed. * Other values indicate that a message was processed */ if (SIRF_TIMEOUT_INFINITE != timeout) { /* Loop around, don't wait and look for another message */ gprs_at_command.semaphore_timeout = 0; gprs_at_command.command_timeout_left = timeout; continue; } /* Now check the state to see if we are still waiting for a response. If * we are then we can't process any input messages yet and must wait until * the timout before proceding. Check to see if the timeout has occured * and if not update the timeout values */ else if (GPRS_SERVER_STATE_AT_RESPONSE == gprs_at_command.state ) { if ((SIRF_SUCCESS != semaphore_result) && (wait_elapsed >= gprs_at_command.command_timeout_left)) { /* This is an error case. We timed out waiting for the expected * response, Send up an error message and continue */ handle_response_timeout(); gprs_at_command.state = GPRS_SERVER_STATE_AT_COMMAND; } else { /* Adjust the timeout for the time elapsed waiting */ gprs_at_command.command_timeout_left -= wait_elapsed; gprs_at_command.semaphore_timeout = gprs_at_command.command_timeout_left; } /* In either case, continue */ continue; } result = process_next_msg( &gprs_at_command.msg_queue_gprs_input, handle_input_msg, &gprs_at_command.semaphore_timeout); if (SIRF_SUCCESS != result) { /* really bad error occured here, send it to the listeners */ handle_unexpected_result(result); SIRF_PAL_OS_THREAD_Sleep(10); } else { gprs_at_command.command_timeout_left = gprs_at_command.semaphore_timeout; } } /* while()*/ SIRF_PAL_OS_THREAD_RETURN(); } /* SIRF_EXT_UART_ReadThread()*/
SIRF_PAL_OS_THREAD_DECL SIRF_EXT_AUX_CommThread(SIRF_PAL_OS_THREAD_PARAMS) { tSIRF_UINT32 BytesRead = 0; /* byte count in raw message buffer */ tSIRF_UINT8 Buf[MAX_BUFFER_SIZE]; /* raw message buffer */ /* Unused Parameters. */ SIRF_PAL_OS_THREAD_UNUSED SIRF_PAL_OS_THREAD_START(); b_Aux_Thread_Running = SIRF_TRUE; SIRF_PAL_OS_SEMAPHORE_Wait( c_aux_open_sem, SIRF_PAL_OS_TIMEOUT_INFINITE ); SIRF_PAL_COM_Open( c_ExtAuxHandle, c_ExtAuxPort, SIRF_PAL_COM_FC_NONE, c_ExtAuxBaudRate ); /* the caller is waiting for this to go to zero before moving on to the next port */ c_auxno_set = 0; while ( SIRF_FALSE != b_Aux_Thread_Running ) { tSIRF_RESULT wait; /* sit on this event flag until something arrives for us to do */ wait = SIRF_PAL_COM_Wait( c_ExtAuxHandle, 100 ); if (wait == SIRF_PAL_COM_TIMEOUT) { /* Timed out after 1000ms of nothing, go again. */ continue; } else if (wait != SIRF_SUCCESS) { /* The port failed (perhaps due to a close/open). Yield. */ SIRF_PAL_OS_THREAD_Sleep(100); continue; } /* we might have waited quite awhile; don't artificially delay the user */ if (SIRF_FALSE == b_Aux_Thread_Running) { /* note: this guards against a race condition where we run the rest of this pass while the rest of the code is halted */ break; } /* try to get some work; if it was a false positive, try again */ if (SIRF_PAL_COM_Read(c_ExtAuxHandle, Buf, sizeof(Buf), &BytesRead) != SIRF_SUCCESS) { continue; } if ( BytesRead ) { /* Log all of the incoming data */ #ifdef SIRF_EXT_LOG //!! SIRF_EXT_LOG_Send_Passthrough((unsigned char * ) Buf, BytesRead); /* Is this what we want? */ #endif /* Send the data to the callback function, if it is registered */ if ( f_callback ) { f_callback( (tSIRF_UINT8 *)&Buf, BytesRead ); } } } // while{} SIRF_PAL_COM_Close( c_ExtAuxHandle ); SIRF_PAL_OS_THREAD_RETURN(); } /* SIRF_EXT_AUX_CommThread */