C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/Devices/AwareGeigerCounter.cs


using System;
using System.IO;
using System.IO.Ports;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;

using NewGamePhysics.Utilities;

namespace NewGamePhysics.Devices
{
    public delegate void GeigerCounterEvent(double relativeTime);

    public class AwareGeigerCounter : IDisposable
    {
        private const UInt32 MS_RING_ON = 0x0040;

        private GeigerCounterEvent eventHandler;

        private SerialPort serialPort;

        private IntPtr serialPortHandle;

        private bool lastRingOn = false;

        public AwareGeigerCounter(string portReference)
        {
            if (string.IsNullOrEmpty(portReference))
            {
                throw new ArgumentNullException(
                    "portReference",
                    "The port reference cannot be null or empty");
            }

            string[] portNames = System.IO.Ports.SerialPort.GetPortNames();
            string portName;

            if ((portNames == null) || (portNames.Length == 0))
            {
                throw new ApplicationException(
                    "No serial ports are available on this system");
            }

            if (!Array.Exists(portNames, s => s.ToUpper().Contains(portReference.ToUpper())))
            {
                try
                {
                    int portIndex = Convert.ToInt32(portReference);

                    if ((portIndex < 1) || (portIndex > portNames.Length))
                    {
                        SerialPortInfo(portNames);
                        throw new ArgumentOutOfRangeException(
                            "portIndex",
                            "The port index must be in the range 1 to " + portNames.Length);
                    }

                    portName = portNames[portIndex - 1];
                }
                catch (Exception)
                {
                    SerialPortInfo(portNames);
                    throw;
                }
            }
            else
            {
                portName = portReference;
            }

            this.InitializePort(portName);
        }

        public void Dispose()
        {
            if (this.serialPort != null)
            {
                this.serialPortHandle = (IntPtr)0;
                this.serialPort.PinChanged -= new SerialPinChangedEventHandler(PinChanged);
                this.serialPort.Close();
                this.serialPort.Dispose();
                this.serialPort = null;
            }
        }

        ~AwareGeigerCounter()
        {
            this.Dispose();
        }

        public GeigerCounterEvent EventHandler
        {
            set { eventHandler = value; }
        }
        private void SerialPortInfo(string[] portNames)
        {
            System.Console.WriteLine();
            System.Console.WriteLine("Available Serial Ports:");
            for (int i = 0; i < portNames.Length; i++)
            {
                System.Console.WriteLine(" port #" + (i + 1) + " on: " + portNames[i]);
            }
            System.Console.WriteLine();
        }

        private void InitializePort(string portName)
        {
            // New serial port
            this.serialPort = new SerialPort(portName, 2400);

            // Power the device
            this.serialPort.Open();
            this.serialPort.DtrEnable = true;
            this.serialPort.RtsEnable = false;

            // Get a Win32 handle to serial port
            FieldInfo internalStreamFieldInfo = typeof(SerialPort).GetField(
                "internalSerialStream",
                BindingFlags.NonPublic | BindingFlags.Instance);
            object internalStream = internalStreamFieldInfo.GetValue(this.serialPort);
            Type internalStreamType = internalStream.GetType();
            FieldInfo handleFieldInfo = internalStreamType.GetField(
                "_handle",
                BindingFlags.NonPublic | BindingFlags.Instance);
            object safeFileHandle = handleFieldInfo.GetValue(internalStream);
            this.serialPortHandle = ((SafeFileHandle)safeFileHandle).DangerousGetHandle();

            // Connect event to detect counts on RI pin
            this.serialPort.PinChanged += new SerialPinChangedEventHandler(PinChanged);
        }

        [DllImport("kernel32.dll")]
        private static extern Boolean GetCommModemStatus(IntPtr hFile, out UInt32 lpModemStat);

        private void PinChanged(object sender, SerialPinChangedEventArgs e)
        {
            if (e.EventType == SerialPinChange.Ring)
            {
                // Gate event by checking for down edge of ring bit change
                uint status;
                if (GetCommModemStatus(this.serialPortHandle, out status))
                {
                    bool ringOn = (status & MS_RING_ON) != 0;
                    if ((this.lastRingOn) && (!ringOn))
                    {
                        if (null != this.eventHandler)
                        {
                            this.eventHandler(HighResolutionTimer.Seconds());
                        }
                    }

                    this.lastRingOn = ringOn;
                }
                else
                {
                    string message = "GetCommModemStatus() error: " +
                        Marshal.GetLastWin32Error().ToString();
                    throw new ApplicationException(message);
                }
            }
        }
    }
}

---