MoebiusIT

The parallel port, like most of the hardware, is becoming each day more unknown to the developers. We are getting used to languages that encapsulate all these low level things for us.

Well, recently I found myself needing to wake up an application of mine when the signal of the parallel port changed. This is what I did!

Intro

When I started sketching the behavior of my ParallelPortListener I decided not to go deeper into the OS trying to reach the IRQs. I preferred a code not as optimal but much cleaner and maintainable.

Here is the Source Code.

Code Arrangement

The code is composed of two classes: the ParallelPortListener I told you before and an internal class I called PortAccess whose only task is to call a method, Input(int address), from a dll I’ll talk about later.

ParallelPortListener Class

ParallelPortListener is also composed of many portions of code, each one with a very different purpose:

• The implementation of a Singleton.
  This class is a Singleton because I didn’t want simultaneous reads to the port (another possibility was to use the locking mechanisms)
• A delegate OnPortChangedHandler
• A public event OnPortChanged where outsiders can subscribe methods matching the signature of OnPortChangedHandler
• A Listener section which contains a Timer that invokes the PortAccess class, and two methods to control this Timer: Start and Stop

Ok, too much introduction, let’s see some code!

Port Access

using System.Runtime.InteropServices; //This namespace contains DllImportAttribute

namespace Utilities
{
	public class PortAccess
	{
		[DllImport("inpout32.dll", EntryPoint = "Out32")]
		public static extern void Output(int adress, int value);

		[DllImport("inpout32.dll", EntryPoint = "Inp32")]
		public static extern int Input(int adress);
	}
}

I call the external function “Out32″ in the dll “inpout32.dll” by adding the attribute System.Runtime.InteropServices.DllImport to my method Output.
The external function name is set in EntryPoint, I also had to set the dll name, in this case “inpout32.dll”.

Note: It’s important to remember that inpout32.dll must be on the same location where the application is running.

The best way to be sure you won’t forget is letting VS take care of it.

1. Add inpout32.dll to your solution
2. Right click on the file and go to properties
3. Set “Build Action” to “Content”
4. Set “Copy to Output Directory” to “Copy if newer”

ParallelPortListener

Public Properties

The setter is private, only the class can set the value

public int PortValue { get; private set; }

Singleton

private ParallelPortListener() { }

private static readonly ParallelPortListener _instance = new ParallelPortListener();
public static ParallelPortListener Instance { get { return _instance; } }

I like this way of implementing the pattern but there are others

Delegate

Delegate to handle the event

public delegate void PortChangedHandler(int portValue);

Event

And here we have some interesting code, how to create an event.

private event PortChangedHandler _portChanged;
public event PortChangedHandler OnPortChanged
{
	add
	{
		_portChanged += value;
		Start();
	}
	remove
	{
		_portChanged -= value;
		if (_portChanged.GetInvocationList().Length == 0) { Stop(); }
	}
}

private void PortChanged()
{
	if (_portChanged != null)
	{
		_portChanged(PortValue);
	}
}

Instead of Start I could have used “if (_portChanged.GetInvocationList().Length == 1) { Start(); }”, but I know my method and checking that is more expensive  than calling it.
When I call Stop checking is mandatory.

OnPortChanged is where handlers register themselves to observe the port, when someone registers I Start the ParallelPortListener.
The private method PortChanged is called by the Listen method (keep reading) when the PortValue changes.

Listener section

Let’s define two constants: LISTEN_FREQUENCY and PORT_ADDRESS

private const UInt32 LISTEN_FREQUENCY = 100; //100ms
private const Int32 PORT_ADDRESS = 889;

The address 889 is for reading the parallel port.

private Timer _timerListen;

//Starts the Timer
private void Start()
{
	if (_timerListen == null)
	{
		_timerListen = new Timer(Listen, null, 0, LISTEN_FREQUENCY);
	}
}

//Stops the Timer
private void Stop()
{
	if (_timerListen != null)
	{
		_timerListen.Dispose();
		_timerListen = null;
	}
}

private void Listen(Object unusedParameter)
{
	int newPortValue = PortAccess.Input(PORT_ADDRESS);
	if (newPortValue != PortValue) //If the value has changed
	{
		PortValue = newPortValue; //Update PortValue
		PortChanged(); //Notify the listeners
	}
}

This Timer is used to Listen the port every LISTEN_FREQUENCY and update PortValue if necessary.

I hope you’ll find this code useful, download it and if you have any doubts or comment feel free to post!

References

How to program a parallel port using c# the way you want
Implementing Singleton in C#
Timer Class

Tags: C#, Delegate, dotnet, Event, Parallel Port, Singleton, Timer

This entry was posted on Friday, April 3rd, 2009 at 6:27 pm and is filed under MoebiusIT. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.