Posting Windows Messages Accross Processes

public class WinMessagePoster
{
  [DllImport("user32")]
  public static extern bool PostMessage(IntPtr hwnd, int msg, 
          IntPtr wparam, IntPtr lparam);

  [DllImport("user32")]
  public static extern int RegisterWindowMessage(string message);

  // this class just wraps some Win32 stuffthat we're going to use
  public const int HWND_BROADCAST = 0xffff;

  public static readonly int WM_APP_MYMESSAGE = 
                                 RegisterWindowMessage("WM_APP_MYMESSAGE");

  public void PostWinMessageToAnotherApp()
  {
    Process[] processes = Process.GetProcessesByName("ApplicatioName");
    foreach (Process p in processes)
    {
      IntPtr pFoundWindow = p.MainWindowHandle;
      PostMessage(pFoundWindow, "WM_APP_MYMESSAGE", IntPtr.Zero, IntPtr.Zero);
    }
  }
}

In the application that receives the windows message

// In .exe Main Form
#region Detect Custom Windows Message

public static readonly int WM_APP_MYMESSAGE = 
  RegisterWindowMessage("WM_APP_MYMESSAGE");

[DllImport("user32")]
public static extern int RegisterWindowMessage(string message);

protected override void WndProc(ref Message m)
{
  if (m.Msg == WM_APP_MYMESSAGE)
  {
    DoSomething();
  }
  base.WndProc(ref m);
}

#endregion Detect Custom Windows Message

GPS Serial Port Provider

For the actual serial port provider we have a base class. This takes care of all the serial port side of things

using System;
using System.Collections.Generic;
using System.Text;
using System.IO.Ports;
using System.Diagnostics;

namespace GpsTest
{
  public abstract class SerialPortGpsProviderBase : IGpsDataProvider
  {
    /// <summary>
    /// Fire this event when A GPS line of data has been received
    /// </summary>
    public event GpsDataReceivedEventHandler GpsDataReceived;

    #region Attributes

    protected SerialPort comPort = new SerialPort();

    #endregion

    public SerialPortGpsProviderBase()
    {
    }

    ~SerialPortGpsProviderBase()
    {
      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
        comPort.Dispose();
      }
      m_disposed = true;
    }

    #endregion

    public bool IsOpen()
    {
      return comPort.IsOpen;
    }

    public void Open()
    {
      //set up the delegate used to read data in.......
      comPort.DataReceived += new SerialDataReceivedEventHandler(comPort_DataReceived);

      try
      {
        //finally open the port....
        comPort.Open();
        Trace.WriteLine("Com port " + comPort.ToString() + " Open=" + comPort.IsOpen.ToString());
      }
      catch (System.Exception ex)
      {
        Trace.WriteLine(DateTime.Now.ToString() + 
           ": Failed to open COM port with exception: " + ex.Message);
      }
    }

    protected abstract void comPort_DataReceived(object sender, 
            SerialDataReceivedEventArgs e);

    protected void FireGpsDataReceived(string data)
    {
      try
      {
        if ((data.Length > 0) &&
            (GpsDataReceived != null))
        {
          GpsDataReceived(this, new GpsDataLineEventArgs(data));
        }
      }
      catch (System.Exception ex)
      {
        Trace.WriteLine(DateTime.Now + 
            ": Failed to extract GPS data in comPort_DataReceived: " +
             ex.Message);
      }
    }


    public void Close()
    {
      try
      {
        //check we have a valid COM port to close...
        if (comPort.IsOpen)
        {
          comPort.Close();
          Debug.WriteLine("Com port " + comPort.ToString() + " CLOSED");
        }
      }
      catch (System.Exception ex)
      {
        Trace.WriteLine(DateTime.Now.ToString() + 
                ": Failed to close COM port with exception: " +
                ex.Message);
      }
    }
  }

}

The actual provider just implements the code to read the data and parse it

using System;
using System.Collections.Generic;
using System.Text;
using System.IO.Ports;
using System.Diagnostics;

namespace GpsTest
{

  // First simple provider 
  public class GpsSerialPortDataProvider : SerialPortGpsProviderBase
  {
    #region Attributes

    private const string comPortName = "COM14"; 
    private const int baudRate = 4800;

    #endregion

    public GpsSerialPortDataProvider()
    {
      //set up the com port settings.....
      comPort.PortName = comPortName;
      comPort.BaudRate = baudRate;
      comPort.Parity = Parity.None;
      comPort.StopBits = StopBits.One;
      comPort.DataBits = 8;
      comPort.Handshake = Handshake.None;
      comPort.ReadTimeout = 1000;
      comPort.NewLine = "\r\n";
    }

    ~GpsSerialPortDataProvider()
    {
      Dispose(false);
    }

    protected override void comPort_DataReceived(
      object sender, 
      SerialDataReceivedEventArgs e)
    {
      //Read a line of GPS data (each is sent with a \r\n at the end)
      try
      {
        string data = comPort.ReadLine();
        FireGpsDataReceived(data);
      }
      catch (System.Exception ex)
      {
        Trace.WriteLine(DateTime.Now + 
          ": Failed to extract GPS data in comPort_DataReceived: "
          + ex.Message);
      }
    }

  }

}

Due to a driver fault on the device we were using we could not read the data a line at a time. We had to clear the buffer out every time we read it, so here is the alternative provider

using System;
using System.Collections.Generic;
using System.Text;
using System.IO.Ports;
using System.Diagnostics;

namespace GpsTest
{

public class GpsSerialPortDataProvider3 : SerialPortGpsProviderBase
{

  #region Attributes

  private const string comPortName = "COM14";
  private const int baudRate = 4800;

  #endregion

  public GpsSerialPortDataProvider3()
  {
    //Setup the COM port
    comPort.PortName = comPortName;
    comPort.BaudRate = baudRate;

    //set up the other settings.....
    comPort.Parity = Parity.None;
    comPort.StopBits = StopBits.One;
    comPort.DataBits = 8;
    comPort.Handshake = Handshake.None;
    comPort.ReadTimeout = 1000;
    comPort.ReceivedBytesThreshold = 256;
  }

  ~GpsSerialPortDataProvider3()
  {
    Dispose(false);
  }

  private string buffer = "";
  private object bufferLock = new object();

  protected override void comPort_DataReceived(object sender, 
           SerialDataReceivedEventArgs e)
  {
    //Read a line of GPS data (each is sent with a \r\n at the end)
    try
    {
      // Read out everything in the buffer
      string data = comPort.ReadExisting();
      if (data.Length > 0)
      {
        string ready = string.Empty;
        lock (bufferLock)
        {
          buffer += data;
          // Do we have any complete lines in the buffer
          int ix = buffer.LastIndexOf("\r\n");
          if (ix >= 0)
          {
            // Remove all the complete lines
            ready = buffer.Remove(ix);
            // Truncate the buffer any incomplete data at the end
            buffer = buffer.Remove(0, ix + 2);
          }
        }
        if (ready.Length > 0) // found some complete lines
        {
          // Extract them
          string[] lines = ready.Split(new string[] { "\r\n" },
               StringSplitOptions.RemoveEmptyEntries);
          foreach (string line in lines)
          {
            // Invoke the GpsDataReceived event with the complete line
            FireGpsDataReceived(line);
          }
        }

      }
    }
    catch (System.Exception ex)
    {
      Trace.WriteLine(DateTime.Now.ToString() + 
           ": Failed to extract GPS data in comPort_DataReceived: " +
            ex.Message);
    }
  }

}

}

GPS Monitoring Test Provider

Here is a test provider

using System;
using System.Collections.Generic;
using System.Text;
using System.Timers;
using System.Diagnostics;
using System.IO;

namespace GpsTest
{
  class GpsTestProvider : IGpsDataProvider, IDisposable
  {
    Timer timer = new Timer();
    int index = 0;
    string[] sampleData = new string[]
      {
          "$GPRMC,135150.000,A,5106.7058,N,00123.8886,W,4.07,192.74,250808,,,A*74",
          "$GPRMC,135151.000,A,5106.7044,N,00123.8903,W,4.75,210.87,250808,,,A*74",
          "$GPRMC,135152.000,A,5106.7037,N,00123.8916,W,3.52,212.41,250808,,,A*7D",
          "$GPRMC,135153.000,A,5106.7033,N,00123.8927,W,2.88,208.03,250808,,,A*71",
          "$GPRMC,135154.000,A,5106.7030,N,00123.8928,W,2.72,205.69,250808,,,A*7E",
          "$GPRMC,135155.000,A,5106.7024,N,00123.8942,W,2.70,211.83,250808,,,A*75",
          "$GPRMC,135156.000,A,5106.7021,N,00123.8945,W,1.60,188.74,250808,,,A*7D",
          "$GPRMC,135157.000,A,5106.7017,N,00123.8945,W,1.21,168.54,250808,,,A*70",
      };


    public GpsTestProvider()
    {
      const string sampleDataFile = "GPSTestData.txt";
      if (File.Exists(sampleDataFile))
      {
        sampleData = File.ReadAllLines(sampleDataFile);
      }
    }

    #region Dispose Implementation

    // Use C# destructor syntax for finalization code.
    ~GpsTestProvider()
    {
      Debug.Assert(false, "This object was not disposed of");
      Dispose(false);
    }

    private bool m_Disposed = false;

    //Implement IDisposable.
    public void Dispose()
    {
      Dispose(true);
      GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
      if (m_Disposed)
        return;

      if (disposing)
      {
        // TODO: cleanup managed resources in GpsTestProvider
      }
      Close();
      timer.Dispose();

      m_Disposed = true;
    }

    #endregion Dispose Implementation


    #region IGpsDataProvider Members

    public void Close()
    {
      timer.Stop();
      timer.Enabled = false;
    }

    public event GpsDataReceivedEventHandler GpsDataReceived;

    public void Open()
    {
      timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
      timer.Interval = 100;
      timer.Start();
      timer.Enabled = true;
    }

    public bool IsOpen()
    {
      return timer.Enabled;
    }
    #endregion

    void timer_Elapsed(object sender, ElapsedEventArgs e)
    {
      if (GpsDataReceived != null)
      {
        GpsDataReceived(this, new GpsDataLineEventArgs(sampleData[index]));
        index = (index + 1) % sampleData.Length;
      }
    }

  }
}

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 }