GPS Monitoring

Here is the structure view of the Gps Design: Define the provider interface

  public interface IGpsDataProvider
  {
    void Close();
    event GpsDataReceivedEventHandler GpsDataReceived;
    void Open();
    bool IsOpen();
  }

Later we can derive a test provider Here are the event helpers

    public delegate void GPSDataEventHandler(object sender, GPSDataEventArgs e);

    public class GPSDataEventArgs : EventArgs
    {
        #region Members
        private GPSFix m_FixState = GPSFix.NoFix;
        private double m_Longitude = 0;
        private double m_Latitude = 0;
        private double m_SpeedMetresPerSec = 0;
        private double m_BearingDegrees = 0;
        #endregion

        #region Properties
        public GPSFix FixState { get { return m_FixState; } }
        public double Longitude { get { return m_Longitude; } }
        public double Latitude { get { return m_Latitude; } }
        public string CoordinateSystem { get { return GpsListener.coordindateSystem; } }
        public double SpeedMetresPerSec { get { return m_SpeedMetresPerSec; } }
        public double BearingDegrees { get { return m_BearingDegrees; } }
        #endregion

        #region Constructor
        public GPSDataEventArgs(GPSFix a_FixState, double a_Longitude, 
                  double a_Latitude, double a_SpeedMetresPerSec, 
                  double a_BearingDegrees)
        {
            m_FixState = a_FixState;
            m_Longitude = a_Longitude;
            m_Latitude = a_Latitude;
            m_SpeedMetresPerSec = a_SpeedMetresPerSec;
            m_BearingDegrees = a_BearingDegrees;
        }
        #endregion

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder(128);
            sb.Append(" FixState=" + m_FixState.ToString());
            sb.Append(" Long=" + m_Longitude.ToString());
            sb.Append(" Long=" + m_Longitude.ToString());
            sb.Append(" Lat=" + m_Latitude.ToString());
            sb.Append(" Speed=" + m_SpeedMetresPerSec.ToString());
            sb.Append(" Bearing=" + m_BearingDegrees.ToString());
            return sb.ToString();
        }
    }

    public delegate void GpsDataReceivedEventHandler(object sender,
              GpsDataLineEventArgs e);

    public class GpsDataLineEventArgs : EventArgs
    {
        #region Members
        private string m_Data = string.Empty;
        #endregion

        #region Properties

        public string Data
        {
            get { return m_Data; }
            set { m_Data = value; }
        }

        #endregion

        #region Constructor
        public GpsDataLineEventArgs(string data)
        {
            m_Data = data;
        }
        #endregion
    }

Here is the Listener: public enum GPSFix { NoFix = 0, SatelliteFix = 1, NonSatelliteFix = 2 } /// <summary> /// The comPort_DataReceived event is coming in on a worker thread. It could /// happen that 2 worker threads do their work simultaneously, in which case, /// some serial port methods could be called at the same time on different /// threads and BANG! /// Now, when the data event handler is called it stuffs the /// data onto a stack and releases the GPS Thread (using the AutoResetEvent). /// It then returns immediately. /// The GPS thread first check if less than 12 seconds (an adjustable /// sampling interval) have expired since /// receiving the last GPS position. If it has the stack is emptied. After 12 /// seconds the thread processes the stack until it finds a valid GPS /// position line of data. When it does it uses a worker thread to invoke /// the GPSEvent method passing the line of data. /// </summary> public class GpsListener { #region Attributes // Really, this should stuff its received data into a thread safe queue public event GPSDataEventHandler GPSDataEventHandler; private IGpsDataProvider gpsProvider = null; private GPSFix currentFix = GPSFix.NoFix; //default to no fix private double currentLongitude = 0.0; private double currentLatitude = 0.0; public const string coordindateSystem = "WGS84"; private double currentSpeed = 0.0; private double currentBearing = 0.0; private double lastTimeStamp = -1; //GPS data format definitions private readonly string gpsLineHeader = "$GPRMC"; private const int timeStampIdx = 1; private const int fixIdx = timeStampIdx + 1; private const int latitudeIdx = fixIdx + 1; private const int longitudeIdx = latitudeIdx + 2; private const int speedIdx = longitudeIdx + 2; private const int bearingIdx = speedIdx + 1; private readonly char fixChar = 'A'; private readonly char nonfixChar = 'V'; //private Form1 m_gui; #endregion public GpsListener(IGpsDataProvider provider) { gpsProvider = provider; } ~GpsListener() { Dispose(false); } #region IDisposable Members private bool m_disposed = false; public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } protected virtual void Dispose(bool disposing) { if (!m_disposed) { if (disposing) { // Dispose managed resources } // Dispose unmanaged resources if (gpsProvider is IDisposable) { ((IDisposable)gpsProvider).Dispose(); } EndThread(); } m_disposed = true; } #endregion public void Initialise() { StartThread(); //gpsProvider = new GpsSerialPortDataProvider(); gpsProvider.GpsDataReceived += new GpsDataReceivedEventHandler(gpsProvider_GpsDataReceived); gpsProvider.Open(); } public bool IsInitialised() { return (m_Thread != null); } void gpsProvider_GpsDataReceived(object sender, GpsDataLineEventArgs e) { // Put the recieved line of data into the queue and return // The Gps Monitoring thread will do something with it lock (m_GPSInputLock) { m_GPSInput.Push(e.Data); } m_PauseEvent.Set(); } public bool DataReceived { get { return (lastTimeStamp != -1); } } public GPSFix FixState { get { return currentFix; } } public double Longitude { get { return currentLongitude; } } public double Latitude { get { return currentLatitude; } } public string CoordinateSystem { get { return coordindateSystem; } } public double SpeedMetresPerSec { get { return currentSpeed; } } public double BearingDegrees { get { return currentBearing; } } #region Private Threading Related /// <summary> /// Lines of data. The most recent data is highest in the stack /// This is the data variable shared by the thread routine and /// the rest of the class /// </summary> Stack<string> m_GPSInput = new Stack<string>(); /// <summary> /// Controls access to m_GPSInput /// </summary> object m_GPSInputLock = new object(); /// <summary> /// Actual threa object /// </summary> private Thread m_Thread = null; /// <summary> /// Give the thread a meaningful threadId /// </summary> private string threadId = "GPSMonitoringThread"; /// <summary> /// We use the m_PauseEvent to control the sleep period /// of the thread. The m_PauseEvent /// sleeps for the given period but we can force it to /// wake up early by calling /// Set on it. /// </summary> private AutoResetEvent m_PauseEvent = new AutoResetEvent(false); /// <summary> /// This does not need special protected access. /// It is set to false before the thread is /// started and can only get set to true when /// the thread thread has begun. /// </summary> private bool m_Stop = false; /// <summary> /// Start the thread running /// </summary> private void StartThread() { if (m_Thread != null) { EndThread(); } if (m_Thread == null) { if (m_PauseEvent == null) { m_PauseEvent = new AutoResetEvent(false); } m_Stop = false; m_Thread = new Thread(new ThreadStart(this.ThreadRoutine)); m_Thread.IsBackground = true; m_Thread.Start(); m_Thread.Name = threadId; Thread.Sleep(0); } } /// <summary> /// EndThread to the thread to terminate it /// </summary> private void EndThread() { m_Stop = true; if (m_Thread != null) { if (m_PauseEvent != null) { m_PauseEvent.Set(); Thread.Sleep(100); } m_Thread = null; if (m_PauseEvent != null) { m_PauseEvent.Close(); m_PauseEvent = null; } } } /// <summary> /// The routine executed within the new thread /// </summary> private void ThreadRoutine() { string thrdName = m_Thread.Name; System.Diagnostics.Debug.WriteLine("Thread \'" + thrdName + "\' thread routine is started"); try { while (m_Stop != true) { ThreadWork(); if (m_Stop != true) m_PauseEvent.WaitOne(); } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("FATAL exception caught in thread routine \'" + thrdName.ToString() + "\' Thread will be terminated" + ex.ToString()); } System.Diagnostics.Debug.WriteLine("Thread \'" + thrdName + "\' end of thread routine reached"); } int m_LastValidDataTime = Environment.TickCount; // Change this to the required value const int SAMPLING_INTERVAL = 3000; // 3 seconds minimum sampling interval private void ThreadWork() { int tmp = m_LastValidDataTime + SAMPLING_INTERVAL; // Not interested in any data while sampling interval is not finished if (tmp > Environment.TickCount) { lock (m_GPSInputLock) { m_GPSInput.Clear(); } return; } // Wont protect access to m_GPSInput here, so what if it is wrong while (m_GPSInput.Count > 0) { string data = string.Empty; try { lock (m_GPSInputLock) { data = m_GPSInput.Pop(); // Start with last known data received } // //comPort. //Have we got any data? if (data != string.Empty) { //Yes - so see if this makes sense.....does it start with the GPS header? if (data.StartsWith(gpsLineHeader)) { Debug.Write("read line " + Environment.TickCount + " " + data + " " + Environment.NewLine); //Yes - so we are in business. Information is comma separated, so split for easy processing.... string[] subStrings = data.Split(','); //Check we have something to process.... if ((subStrings != null) && (subStrings.Length > bearingIdx)) { try { //Ok - extract out the interesting stuff..... double currentTimeStamp = double.Parse(subStrings[timeStampIdx]); char readFixChar = subStrings[fixIdx][0]; double.TryParse(subStrings[latitudeIdx], out currentLatitude); double.TryParse(subStrings[longitudeIdx], out currentLongitude); double.TryParse(subStrings[speedIdx], out currentSpeed); double.TryParse(subStrings[bearingIdx], out currentBearing); //Trace.WriteLine(DateTime.Now.ToString() + " currentLatitude: " + currentLatitude.ToString()); //Trace.WriteLine(DateTime.Now.ToString() + " currentLongitude: " + currentLongitude.ToString()); //Trace.WriteLine(DateTime.Now.ToString() + " currentSpeed: " + currentSpeed.ToString()); //Trace.WriteLine(DateTime.Now.ToString() + " currentBearing: " + currentBearing.ToString()); //default to no fix.... currentFix = GPSFix.NoFix; m_LastValidDataTime = Environment.TickCount; //do any further processing required.....are the timestamps different? if (lastTimeStamp == currentTimeStamp) currentFix = GPSFix.NonSatelliteFix; else if (readFixChar == fixChar) currentFix = GPSFix.SatelliteFix; else if (readFixChar == nonfixChar) currentFix = GPSFix.NoFix; //update the last time stamp.... lastTimeStamp = currentTimeStamp; //If there are those listening - tell the outside world... if (GPSDataEventHandler != null) { GPSDataEventArgs gpsData = new GPSDataEventArgs(currentFix, currentLongitude, currentLatitude, currentSpeed, currentBearing); //fire the event // Asynchronously ThreadPool.QueueUserWorkItem(new WaitCallback(this.GPSDataEventThreadRoutine), gpsData as object); // or synchronously //GPSDataEventHandler(this, gpsData); } } catch (System.Exception ex) { Trace.WriteLine(DateTime.Now.ToString() + ": " + ex.Message); } } } } } catch (InsufficientMemoryException ex) { Trace.WriteLine(DateTime.Now.ToString() + "Insufficient Memory on MDT: " + ex.Message); } catch (TimeoutException ex) { Trace.WriteLine(DateTime.Now.ToString() + ": Timeout Exception, data: " + data + " exception: " + ex.Message); } catch (System.Exception ex) { //Debug.WriteLine("Invalid processing of GPS data. " + ex.Message); Trace.WriteLine(DateTime.Now.ToString() + ": Failed to extract GPS data in comPort_DataReceived: " + ex.Message); } } } /// <summary> /// For firing the gps event asynchronously /// </summary> /// <param name="obj"></param> private void GPSDataEventThreadRoutine(object obj) { try { GPSDataEventArgs gpsData = obj as GPSDataEventArgs; GPSDataEventHandler(this, gpsData); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine( "FATAL exception caught in \'GPSDataEventHandler\' will be terminated" + ex.ToString()); } } #endregion Private Threading Related }