I will be making use of Andrew Kirillov's motion detection code for image acquisition, and the AForge.NET framework, for certain image processing tasks. I'll start off by showing you how the image processing works for this program, and then I'll walk you through the important parts of the code. So, let's begin!

Image processing and laser tracking...

The laser tracking code works by finding the brightest pixel in the webcam's field of view. It is pretty much similar to the code I had written for my previous article - Laser Tracking Camera. However, since quick image processing is necessary for this program to work in real-time, I have modified the code a bit, and now it's much faster than before. The two image processing techniques I have used for optimization are - image cropping and image resizing.

Image cropping is basically just trimming off the edges of an image to keep unwanted things outside the camera's view. Image cropping also reduces the number of pixels in an image, and makes image processing fast. On the other hand, resizing images reduces the pixel resolution of an image. The pixel resolution of an image describes the resolution of an image with the set of two positive integer numbers, where the first number is the number of pixel columns (width), and the second is the number of pixel rows (height). (Examples: 320x 40, 640x480, 1024x768). An image from Wikipedia illustrates:

The picture on the left is sampled at 20x20, and the image on the right is sampled at a higher pixel resolution, 100x100. Obviously, the higher resolution image has more detail. However, in image processing, while increased resolution results in greater information and detail, it comes at the price of memory and computing speed.
For cropping the video feed from a webcam, you can click-and-drag a selection rectangle around the area you would like to keep, and the program would remove everything else.

The selection rectangle is a semi-transparent rubber band rectangle (picture above). A rubber band rectangle (aka focus rectangle), is a reversible rectangle that tracks with the mouse pointer while you move it around. This makes it easy to select the area you want to work on. If you are working with a projector, you can easily select its projected area, and the program would map its coordinates to the coordinates on your computer screen, and remove everything else.

Here's how you can make a rubber-band rectangle between two points (say x1,y1 and x2, y2):

//Compute width and height of rectangle
int width = Math.Abs(x2 - x1);
int height = Math.Abs(y2 - y1);                
//Decide x and y of rectangle
int x = 0, y = 0;
if (x1 < x2)
    x = x1;
else if (x1 > x2)
    x = x2;
if (y1 < y2)
    y = y1;
else if (y1 > y2)
    y = y2;
//Draw the rectangle
Rectangle rect = new Rectangle(x, y, width, height);
Graphics g = Graphics.FromImage(image);
g.FillRectangle(new SolidBrush(Color.FromArgb(60, 184, 184, 0)), rect); //Draws a semi-transparent rectangle using alpha blending
g.Dispose();

You will find this code in the ProcessFrame event in MotionDetector1.cs. Here, x1 and y1 are updated in the MouseDown event of the camera window, whereas x2 and y2 are updated in the MouseMove event.
After we know how big the selected area is, we can trim the edges by using the Bitmap.Clone method:

Bitmap tmpImage0 = image.Clone(new Rectangle(x, y, width, height), 
   System.Drawing.Imaging.PixelFormat.Format24bppRgb);

For resizing the video feed by a certain factor, adjust the resize factor numeric up/down control. If you take a resize factor, say 2, then the program would divide the length and width of the webcam images by 2, and the resulting images would actually be 2^2 = 4x smaller. For example, if your webcam captures images of size 320 by 240, the total number of pixels in each image would be 320 x 240 = 76800.  If we resize these images by a factor of 2, the resulting 160 by 120 size images would contain only 160 x 120 = 19200 pixels (which is 4x less than 76800).

Here's how we can resize an image by a given factor using the Resize filter in the AForge.Imaging library:

AForge.Imaging.Filters.Resize resize = new Resize(image.Width / resizeFactor, image.Height / resizeFactor, InterpolationMethod.NearestNeighbor);

Bitmap tmpImage1 = resize.Apply(tmpImage0);

Just keep in mind that the lesser you resize your images, the more tracking resolution you'd get while tracking lasers. However, since tracking resolution comes at the cost of memory and computing speed, pick a resize factor which works best for your computer and webcam. A resize factor of 2 or 3 usually works fine for me.
After we're done with cropping and resizing, the program can go through the pixels on the image and find the brightest pixel (I'm assuming this would be the laser dot):

for (int y = 0; y < 240; y++)
{
    for (int x = 0; x < 320; x++) 
    {
        byte red, green, blue;

        red = uBitmap.GetPixel(x, y).red;
        green = uBitmap.GetPixel(x, y).green;
        blue = uBitmap.GetPixel(x, y).blue;
        
        float brightness = (299 * red + 587 * green + 114 * blue) / 1000; 

        if (brightness > certainValue)
            // Do something
    }
}

Here, uBitmap, is an instance of the UnsafeBitmap class I had discussed in my previous article.

NOTE: If you find brightness tracking unreliable in certain lighting conditions, change the above code to perform color detection instead of brightness detection by writing something like "if ((red > 220) && (green < 170) && (blue < 170))" instead of writing "if (brightness > certainValue)".
After our program has the x and y coordinates of the laser dot, it can compute its position on the screen:

//Get screen width and height
int screenWidth = Screen.GetBounds(this).Width;
int screenHeight = Screen.GetBounds(this).Height;
float cursorX, cursorY;

//Compute location of laser dot into camera coordinates
cursorX = ((float)screenWidth / imageWidth) * x;
cursorY = ((float)screenHeight / imageHeight) * y;
       
//Set cursor position
Cursor.Position = new Point((int)cursorX, (int)cursorY);

Now that you know how the code works, lets move on to the next section, in which I will tell you how to use it.

Some notes on using the software

• The program searches for the brightest pixel in the camera's field of view, so the lighting conditions of your room can affect its performance. Adjust the brightness threshold and lighting conditions so that nothing (except the laser) exceeds the brightness threshold. If this doesn't work, change the brightness detection code to perform color detection instead (as described earlier).

• If you want to reset video cropping to normal, just right-click anywhere in the camera window.
• For clicking on something with a laser pointer, just turn off the laser when the mouse cursor is over the item you want to click on. Turning the laser off simulates a left button, single-click. You might also want to change your Folder Options to allow files/folders to be opened with single-clicks.

• While selecting a resize factor, remember that computing speed would come at the cost of tracking resolution. Say, for example, if I use a resize factor of 1, I'd get pretty good tracking resolution, but my program would slow down to a crawl. On the other hand, if I pick a resize factor greater than 4 or 5, I'd get a decent frame rate, but horrible tracking resolution. These values could be different for you (depending on your webcam and computer). For my computer, a resize factor of 2 or 3 works fine and I get about 27-30 frames/second.

Conclusion

We have reached the end of this article, and I hope you enjoyed reading it. Now, here's some homework for you: Try implementing features like double clicking, right clicking and click-drag. If you've watched the video for this article, you must have noticed that I was drawing stuff on MS-Paint using this program. For accomplishing this, I had to modify my code to perform click-drag. If you can think of an easier, laser-based way to switch between different clicking modes, I think that would be very cool. So, use your ideas, and if you end up doing something cool, I'd love to hear about it. Have fun!

About the Author

Ashish Derhgawen is an IT student, currently living in New Delhi, India. He has been coding since fourth grade. Some of his other interests are harmonica playing, wildlife and cricket. When he’s not at school, he spends his time working on unusual projects related to robotics, webcams, and electronics besides others. You can reach Ashish through his blog at http://ashishrd.blogspot.com.

Mounting your webcam on the motor
I have simply mounted my webcam on a plastic cap. I used a heated nail for poking a hole through the cap's center:

Then, I fixed it on the motor by pushing the motor shaft through the hole:

I taped my webcam on the cap..and that was it.

My setup looks very sloppy, and I'm sure yours will look much better than mine. Anyway, let's move on to the fun part!

Finding the laser dot...

Our code will locate the laser dot by finding the brightest pixel in the webcam's field of view. If something in its view is brighter than the laser, the camera will simply turn towards that point instead of the laser dot. The program captures images from a webcam, using Andrew Kirillov's motion detection code for image acquisition. Then, it scans the pixels in the bitmaps captured. Based on their respective RGB (Red Green Blue) values, it determines how bright they are. We could use the Bitmap.GetPixel() function for accessing pixels and calculating the brightness of any pixel in a bitmap:

using System.Drawing;

Color c = someBitmap.GetPixel(x,y);

float b = c.GetBrightness();

Wow, that's easy! This code was simple to write, and easy to understand. However, unfortunately, it is VERY slow. If you use this code, it might take several seconds to process a single image becase the GetPixel()/SetPixel() methods are too slow for iterating through bitmaps of any real size. So, in this project, we'll make use of the BitmapData class in GDI+ to access the information we want. The BitmapData only allows us to access the data it stores through a pointer. This means that we'll have to use the unsafe keyword to scope the block of code which accesses the data. Based on an article by Eric Gunnerson, here's a class which will perform very quick unsafe image processing:

   1: public unsafe class UnsafeBitmap

   2: {

   3:     Bitmap bitmap;

   4:  

   5:     int width;

   6:     BitmapData bitmapData = null;

   7:     Byte* pBase = null;

   8:  

   9:     public UnsafeBitmap(Bitmap bitmap)

  10:     {

  11:         this.bitmap = new Bitmap(bitmap);

  12:     }

  13:  

  14:     public UnsafeBitmap(int width, int height)

  15:     {

  16:         this.bitmap = new Bitmap(width, height, PixelFormat.Format24bppRgb);

  17:     }

  18:  

  19:     public void Dispose()

  20:     {

  21:         bitmap.Dispose();

  22:     }

  23:  

  24:     public Bitmap Bitmap

  25:     {

  26:         get

  27:         {

  28:             return (bitmap);

  29:         }

  30:     }

  31:  

  32:     public struct PixelData

  33:     {

  34:         public byte blue;

  35:         public byte green;

  36:         public byte red;

  37:     }

  38:  

  39:     private Point PixelSize

  40:     {

  41:         get

  42:         {

  43:             GraphicsUnit unit = GraphicsUnit.Pixel;

  44:             RectangleF bounds = bitmap.GetBounds(ref unit);

  45:  

  46:             return new Point((int)bounds.Width, (int)bounds.Height);

  47:         }

  48:     }

  49:  

  50:     public void LockBitmap()

  51:     {

  52:         GraphicsUnit unit = GraphicsUnit.Pixel;

  53:         RectangleF boundsF = bitmap.GetBounds(ref unit);

  54:         Rectangle bounds = new Rectangle((int)boundsF.X,

  55:       (int)boundsF.Y,

  56:       (int)boundsF.Width,

  57:       (int)boundsF.Height);

  58:  

  59:         width = (int)boundsF.Width * sizeof(PixelData);

  60:         if (width % 4 != 0)

  61:         {

  62:             width = 4 * (width / 4 + 1);

  63:         }

  64:         bitmapData =

  65:       bitmap.LockBits(bounds, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

  66:  

  67:         pBase = (Byte*)bitmapData.Scan0.ToPointer();

  68:     }

  69:  

  70:     public PixelData GetPixel(int x, int y)

  71:     {

  72:         PixelData returnValue = *PixelAt(x, y);

  73:         return returnValue;

  74:     }

  75:  

  76:     public void SetPixel(int x, int y, PixelData colour)

  77:     {

  78:         PixelData* pixel = PixelAt(x, y);

  79:         *pixel = colour;

  80:     }

  81:  

  82:     public void UnlockBitmap()

  83:     {

  84:         bitmap.UnlockBits(bitmapData);

  85:         bitmapData = null;

  86:         pBase = null;

  87:     }

  88:     public PixelData* PixelAt(int x, int y)

  89:     {

  90:         return (PixelData*)(pBase + y * width + x * sizeof(PixelData));

  91:     }

  92: }

Be sure to check Eric's article on unsafe image processing.
This class can be used for retrieving the red, green and blue values of any pixel as shown below:

UnsafeBitmap uBitmap = new UnsafeBitmap (original_bitmap);

uBitmap.LockBitmap();

PixelData pixel = uBitmap.GetPixel (x,y);

uBitmap.UnlockBitmap();

You can also alter the red, green and blue values of any pixel in your bitmap:

UnsafeBitmap.PixelData pData = new UnsafeBitmap.PixelData();

pData.red = value;

pData.green = value;

pData.blue = value;

uBitmap.SetPixel (x, y, pData);

To find a laser dot in a bitmap, we have to go through the pixels in the bitmap and calculate each pixel's brightness to find the brightest one. Based on a pixel's RGB values, you can calculate brightness using this formula:

Brightness = (299 * red + 587 * green + 114 * blue) / 1000

This would give a value between 0 to 255.
Here's a sample code to check the brightness of each pixel in a 320 x 240 bitmap:

for (int y = 0; y < 240; y++)

{ 

    for (int x = 0; x < 320; x++) 

    {

        byte red, green, blue;

        red = uBitmap.GetPixel(x, y).red;

        green = uBitmap.GetPixel(x, y).green;

        blue = uBitmap.GetPixel(x, y).blue;

        float brightness = (299 * red + 587 * green + 114 * blue) / 1000;

        if (brightness > certainValue)

            // Do something

    }

}

After our program has the x and y coordinates of the laser dot, it can calculate the number of steps required to turn the webcam towards that point.

Using the Software
Since the program searches for the brightest pixel in the camera's field of view, the lighting conditions of your room can affect its performance. So, adjust the brightness threshold and lighting conditions so that nothing (except the laser) exceeds the brightness threshold.

If your stepper motor doesn't align your webcam with the laser dot properly, try adjusting the pixels-per-step track bar. It tells the program how much your stepper motor moves with each step. My stepper does 40 pixels/step (20 pixels while half stepping). Even though this isn't necessary, you can actually measure how many pixels your stepper moves in one step. Just comment out the calls to the MoveStepper() event in MotionDetector1.cs and run the program. Keep a laser dot fixed somewhere in your webcam's field of view and check its x coordinate in the Output window. After that, move the stepper one step in any direction with your mouse wheel, and see how much its x coordinate changes. Read my previous article for information on how to move a stepper with a mouse wheel, or simply download the code for doing it from here. Well, I still think it's not necessary that you actually measure how much your stepper moves using this tedious technique. Just play with the pixels-per-step track bar until you get things working perfectly.

Now what?

Now that you can track laser, and have a camera actually follow it, here are some interesting ideas to try:

• Wire two stepper motors to your computer. Then, you could make a dual axis, pan/tilt assembly and have your camera follow laser dots in any direction.
• Use two lasers and make an object tracking camera panner, which makes use of laser rangefinding to track the edge of any moving object.

Conclusion
We've reached end of this article. I hope you enjoyed reading it. Use your imagination and ideas to extend this project. If you come up with something interesting, I'd love to hear about it. Happy coding.

About the Author

Ashish Derhgawen is an IT student, currently living in New Delhi, India. He has been coding since fourth grade. Some of his other interests are harmonica playing, wildlife and cricket. When he's not at school, he spends his time working on unusual projects related to robotics, webcams, and electronics besides others. You can reach Ashish through his blog at http://ashishrd.blogspot.com.

Filed under: hardware hacks, robotics

In this article, we will connect a stepper motor to our computer's parallel port, and then we will write some code to control it with the scroll wheel on a mouse (video). If you have never worked with stepper motors, you will surely have a lot of fun with this project. With stepper motors, you can build things such as robots, automatic fish feeder, or even a computerized etch-a-sketch! I'll start off by discussing the basics of parallel ports and stepper motors. Then, we will build the driver circuit required for connecting a stepper motor to a parallel port. In the final section, we will learn how to communicate with parallel ports and how stepper motors are controlled.

Ashish Derhgawen Ashish Blog Difficulty: Easy Time Required: 1-3 hours Cost: Less Than $50 Software: Visual C# or Visual Basic Express Editions Hardware: A 5-wire unipolar stepper motor (these could also be salvaged from old 5¼" floppy disk drives), ULN2003 IC (stepper motor driver), wire, stripboard (or a solderless breadboard ), solder and DB-25 Male connector (buy these two if you can solder. Soldering is not necessary for doing this project, but it will ensure that your connections are secure), DB25 (female/male) parallel port cable, a multimeter, a power adapter (with voltage rating depending on your motor's requirements) Download: Download WARNING: Before we begin, I would warn you that the PC parallel port can be damaged quite easily if you make incorrect connections. If the parallel port is integrated to the motherboard, repairing a damaged parallel port may be expensive, and in many cases, it is cheaper to replace the whole motherboard than to repair that port.          Your safest bet is to buy an inexpensive I/O card which has a parallel port and use it for your experiment. If you manage to damage the parallel port on that card, replacing it will be easy and inexpensive. Don't let that warning worry you too much, because there is a lot of fun to be had with these types of projects. Find yourself an 'antique' PC, if you can, or just buy an I/O card which has a parallel port. Parallel Port Basics A parallel port is a socket found in personal computers for interfacing with various peripherals such as printers, scanners and even some webcams. On many computers, particularly laptops, the parallel port is omitted for cost savings, and is considered to be a legacy port. However, in laptops, access to the parallel port is still commonly available through docking stations. Here's a picture of a DB-25 parallel printer port on the back of a laptop. When a PC sends data to a printer or other device using a parallel port, it sends 8 bit of data (1 byte) at a time. These 8 bits are transmitted parallel to each other, as opposed to the same eight bits being transmitted serially through a serial port. The pin assignments on a parallel port are as follows:

What are stepper motors?
Stepper motors are brushless, synchronous electric motors which can divide a full rotation into several steps. While conventional electric motors spin continuously, stepper motors only move one step at a time. They can be used for precise motion and position control as they can be turned to a precise angle.
The simplest way to think of a stepper motor is a bar magnet and four coils:

    When current flows through coil "A" the magnet is attracted and moves one step forward. Then, coil "A" is turned off and coil "B" is turned on. Now, the magnet takes another step, and so on. A similar process happens inside a stepper motor, but the magnet is cylindrical and rotates inside the coils. For a stepper motor to move, these coils should be activated in a correct sequence. These sequences are called stepping modes:

1. Single Stepping (Single-Coil Excitation): This is the simplest stepping mode. In this mode, each successive coil is energized and the motor moves one full step at a time. Therefore, a motor with a step angle of 7.5 degrees will rotate through 7.5 degrees with each step. Here's how single stepping works:

2. Half Stepping: The difference between single stepping and half stepping is, that for the same step rate, half stepping gives you half the speed but twice the resolution of a single step. For a motor with a step angle of 7.5 degrees, half stepping it would result in approximately 3.75 degrees of rotation. Here's how it works:

Pulse	Coil 1	Coil 2	Coil 3	Coil 4
1	1	0	0	0
2	1	1	0	0
3	0	1	0	0
4	0	1	1	0
5	0	0	1	0
6	0	0	1	1
7	0	0	0	1
8	1	0	0	1

3. High Torque Stepping (Two-Coil Excitation):

As the name suggests, this stepping mode would result in higher torque:

Pulse	Coil 1	Coil 2	Coil 3	Coil 4
1	1	1	0	0
2	0	1	1	0
3	0	0	1	1
4	1	0	0	1

Now that we know a little about parallel ports and stepper motor, its time to get started!

Building the electronics
The electronics for controlling a stepper motor with a parallel port is very simple. We will be making use of the ULN2003 driver IC, which contains an array of 7 darlington transistors with integrated diode protection, each capable of driving 500mA of current. The easiest method of building the circuit is on an electronic breadboard. They are available at all electronics shops. Here's the circuit:

As you can see in the diagram, D0 (Pin 2) on the parallel port is connected to Pin 1 on the ULN2003 stepper driver IC,
D1 (Pin 3) is connected to Pin 2 on the IC,
D2 (Pin 4) is connected to Pin 3 on the IC, and
D3 (Pin 5) is connected to Pin 4 on the IC.
Wires on a stepper motor are color coded. For identifying which wire belongs to which coil, you could try searching for your motor's specs on the Internet. If you are unable to find detailed information for your motor (like me), then you could simply use a multimeter for identifying the wires on your stepper. First of all, identify the common power wire of your stepper by checking the resistance between pairs of wires using a multimeter. The common power wire will be the wire with only half as much resistance between it and all the others. For my motor, the red wire is the common power wire:

Yellow wire - Coil 1
Brown wire - Coil 2
Red wire - Common power wire
Orange wire - Coil 3
Black wire - Coil 4

However, if your guesses are not right, the motor will not rotate, but will only wiggle from side to side. So, I would recommend reading this article if you're not sure. After you've recognized the wires, just build the circuit on a breadboard or a stripboard. I initially built everything on a breadboard, but in the end, I soldered everything on a stripboard.

   In the picture above, notice that I've inserted the wires from the IC directly into my parallel port. This is a very clumsy thing to do. So, I soldered a DB-25 MALE connector so that it would be easier to plug/unplug the circuit to the parallel port cable:

   Test the circuit with a multimeter and make sure all the connections are correct and that there are no short circuits. Then, plug one end of the parallel port cable to the circuit and the other end to the parallel port socket on your computer. That's it! Its time to write some code!

Let the code do the rest...
Accessing the parallel port was much easier in versions of Windows that did not use the Windows NT kernel. In the DOS and Win9x days, programs could access the parallel port using simple inportb() and outportb() subroutine commands. The OS would happily let programs input and output data to the parallel port in the form of 16-bit integers. However, in operating systems such as Windows XP, access to the parallel port is inhibited. This is when the InpOut32.dll project came. This free library quickly became the standard way to access the parallel port in any version of Windows among people interested in parallel port interfacing and programming.
For using inpout32.dll with your code, place the dll in your System32 folder. Now we'll use P/Invoke as shown below:

 1: private class PortAccess

 2: { 

 3: [DllImport("inpout32.dll", EntryPoint="Out32")]

 4: public static extern void Output(int address, int value);

 5: }

 1: Private Class PortAccess 

 2: Public Declare Sub Output Lib "inpout32.dll" Alias "Out32" (ByVal address As Integer, ByVal value As Integer)

 3: End Class

The PortAccess.Output method takes in two parameters, address and value. For knowing your parallel port address, go to Control Panel > System > Hardware > Device Manager > Ports (COM & LPT) > Printer Port (LPT1/LPT2) > Properties > Resources > Resource Settings. Here, you'll see your parallel port address in hexadecimal format:

As you can see in the screenshot above, my I/O range is "0378 - 037F". Hexadecimal "0x378" is equivalent to "888" in decimal. If you are using LPT2, your address would probably be "0x278" (Decimal equivalent is "632").
Now, a possible call from managed code might look like this:

PortAccess.Output(888, 255);

VB:
PortAccess.Output(888, 255)

Here, decimal "255" is equivalent to "1111 1111" in binary. Sending "255" would set all output ports on your parallel port (D0 - D7), to high. Similarly, sending "0" would set all of them to low.
Lets write some code to move our stepper motor one full step at a time. Recall that in single stepping, each successive coils in the motor are energized in the following sequence, one coil at a time.

Here's a sample code for executing this sequence and moving the stepper in one direction:

C#:

 1: PortAccess.Output(888, 1); // 1 decimal = 0001 binary. This will set D0 to high

 2: System.Threading.Thread.Sleep(100); // delay

 3: PortAccess.Output(888, 2); // 2 decimal = 0010 binary. This will set D1 to high

 4: System.Threading.Thread.Sleep(100); // delay

 5: PortAccess.Output(888, 4); // 4 decimal = 0100 binary. This will set D2 to high

 6: System.Threading.Thread.Sleep(100); // delay

 7: PortAccess.Output(888, 8); // 8 decimal = 1000 binary. This will set D3 to high

VB:

 1: PortAccess.Output(888, 1) ' 1 decimal = 0001 binary. This will set D0 to high

 2: System.Threading.Thread.Sleep(100) ' delay

 3: PortAccess.Output(888, 2) ' 2 decimal = 0010 binary. This will set D1 to high

 4: System.Threading.Thread.Sleep(100) ' delay

 5: PortAccess.Output(888, 4) ' 4 decimal = 0100 binary. This will set D2 to high

 6: System.Threading.Thread.Sleep(100) ' delay

 7: PortAccess.Output(888, 8) ' 8 decimal = 1000 binary. This will set D3 to high

Switch on your motor's power supply by connecting the power adapter. Then try running this piece of code to see if it works!
I like using the scroll wheel on my mouse for controlling the motor. For doing this, first create an enumeration for the different stepping modes:

C#:

 1: private SteppingMode stepMode;

 2:  

 3: private enum SteppingMode

 4: { 

 5: SingleStep, 

 6: HalfStep, 

 7: HighTorqueStep

 8: }

VB:

 1: Dim stepMode As SteppingMode

 2:  

 3: Private Enum SteppingMode 

 4: SingleStep 

 5: HalfStep 

 6: HighTorqueStep

 7: End Enum

The form level variable, stepMode stores the selected stepping mode.
Next, we'll wire the form's MouseWheel event to an event handler. Write the following code the InitializeComponent function or the form's constructor:

C#:
this.MouseWheel += new System.Windows.Forms.MouseEventHandler(this.Form1_MouseWheel);
VB:
AddHandler Me.MouseWheel, AddressOf Me.Form1_MouseWheel

Now, we will provide the implementation of Form1_MouseWheel in our form. I've used a StatusStrip with four labels for displaying the stepping mode, direction of movement, and the decimal value being sent to the parallel port along with its binary representation. For determining the direction in which the scroll wheel rotates, we'll use the MouseEventArts.Delta property, which, in the words of MSDN, gives a signed count of the number of detents the mouse wheel has rotated. A detent is one notch of the mouse wheel. Here's a sample code for single stepping the motor with the scroll wheel:

C#:

 1: private int output = 0;

 2:  

 3: private void Form1_MouseWheel(object sender, MouseEventArgs e)

 4: {

 5: switch (stepMode)

 6: {

 7: case SteppingMode.SingleStep:

 8: // Single Stepping

 9:  

 10: if (e.Delta > 0)

 11: {

 12: if (output == 1) output = 2;

 13: else if (output == 2) output = 4;

 14: else if (output == 4) output = 8;

 15: else if (output == 8) output = 1;

 16: else output = 1;

 17:  

 18: directionStatusStripLabel.Text = "Direction: 1";

 19: decimalStatusStripLabel.Text = "Decimal: " + output.ToString();

 20: binaryStatusStripLabel.Text = "Binary: " + ConvertToBinary(output);

 21: PortAccess.Output(888, output);

 22: }

 23: else

 24: {

 25: if (output == 1) output = 8;

 26: else if (output == 8) output = 4;

 27: else if (output == 4) output = 2;

 28: else if (output == 2) output = 1;

 29: else output = 1;

 30:  

 31: directionStatusStripLabel.Text = "Direction: 0";

 32: decimalStatusStripLabel.Text = "Decimal: " + output.ToString();

 33: binaryStatusStripLabel.Text = "Binary: " + ConvertToBinary(output);

 34: PortAccess.Output(888, output);

 35: }

 36: break;

 37: }

 38: }

 39:  

 40: private string ConvertToBinary(int DecimalValue)

 41: {

 42: // Decimal -> Binary conversion

 43:  

 44: int digit;

 45: string binaryForm = "";

 46: char[] binaryArray;

 47:  

 48: do

 49: {

 50: digit = DecimalValue % 2;

 51: binaryForm += digit;

 52: DecimalValue /= 2;

 53: } while (DecimalValue != 0);

 54:  

 55: //The digits in the variable, binaryForm, are in reverse order

 56: // We will reverse it back to normal.

 57: 

 58: binaryArray = binaryForm.ToCharArray();

 59: Array.Reverse(binaryArray);

 60:  

 61: binaryForm = new string(binaryArray);

 62:  

 63: return String.Format("{0:0000}", int.Parse(binaryForm)); ;

 64: }

VB:

 1: Dim output as Integer = 0

 2: Private Sub MainForm_MouseWheel(ByVal sender As Object, ByVal e As MouseEventArgs)

 3: Select Case (stepMode)

 4: Case SteppingMode.SingleStep

 5: ' Single Stepping

 6: If (e.Delta > 0) Then

 7:  

 8: If (output = 1) Then

 9: output = 2

 10: ElseIf (output = 2) Then

 11: output = 4

 12: ElseIf (output = 4) Then

 13: output = 8

 14: ElseIf (output = 8) Then

 15: output = 1

 16: Else

 17: output = 1

 18: End If

 19:  

 20: directionStatusStripLabel.Text = "Direction: 1"

 21: decimalStatusStripLabel.Text = ("Decimal: " + output.ToString)

 22: binaryStatusStripLabel.Text = ("Binary: " + ConvertToBinary(output))

 23: PortAccess.Output(888, output)

 24:  

 25: Else 'If (e.Delta < 0)

 26:  

 27: If (output = 1) Then

 28: output = 8

 29: ElseIf (output = 8) Then

 30: output = 4

 31: ElseIf (output = 4) Then

 32: output = 2

 33: ElseIf (output = 2) Then

 34: output = 1

 35: Else

 36: output = 1

 37: End If

 38:  

 39: directionStatusStripLabel.Text = "Direction: 0"

 40: decimalStatusStripLabel.Text = ("Decimal: " + output.ToString)

 41: binaryStatusStripLabel.Text = ("Binary: " + ConvertToBinary(output))

 42: PortAccess.Output(888, output)

 43: End If 

 44:  

 45: End Select

 46: End Sub

 47:  

 48: Private Function ConvertToBinary(ByVal decimalValue As Integer) As String

 49: ' Decimal -> Binary conversion

 50:  

 51: Dim binaryForm As String = ""

 52: Dim digit As Integer

 53:  

 54: Do

 55: digit = decimalValue Mod 2

 56: If digit = 0 Then

 57: binaryForm = "0" + binaryForm

 58: Else

 59: binaryForm = "1" + binaryForm

 60: End If

 61:  

 62: decimalValue = decimalValue \ 2

 63: Loop Until decimalValue = 0

 64:  

 65: Return CLng(binaryForm).ToString("0000")

 66: End Function

In the MouseUp event of the form, we'll write some code which will allow us to switch between different stepping modes by right clicking on the form. Left clicking on the form would release the motor (i.e. de-energize the coils).

C#:

 1: private void Form1_MouseUp(object sender, MouseEventArgs e)

 2: {

 3: if (e.Button == MouseButtons.Right)

 4: {

 5: // Switch between different stepping modes

 6:  

 7: switch (stepMode)

 8: {

 9:  

 10: case SteppingMode.SingleStep:

 11: stepMode = SteppingMode.HalfStep;

 12: steppingModeStatusStripLabel.Text = "Step Mode: Half";

 13: break;

 14:  

 15: case SteppingMode.HalfStep:

 16: stepMode = SteppingMode.HighTorqueStep;

 17: steppingModeStatusStripLabel.Text = "Step Mode: High Torque";

 18: break;

 19:  

 20: case SteppingMode.HighTorqueStep:

 21: stepMode = SteppingMode.SingleStep;

 22: steppingModeStatusStripLabel.Text = "Step Mode: Single";

 23: break;

 24:  

 25: }

 26: }

 27: else if (e.Button == MouseButtons.Left)

 28: {

 29: // Release the motor

 30:  

 31: output = 0;

 32: PortAccess.Output(888, output);

 33: decimalStatusStripLabel.Text = ("Decimal: " + output.ToString);

 34: binaryStatusStripLabel.Text = ("Binary: " + ConvertToBinary(output));

 35: }

 36: }

VB:

 1: Private Sub Form1_MouseUp(ByVal sender As Object, ByVal e As MouseEventArgs)

 2:  

 3: If (e.Button = MouseButtons.Right) Then

 4: 'Switch between different stepping modes

 5: Select Case (stepMode)

 6:  

 7: Case SteppingMode.SingleStep

 8: stepMode = SteppingMode.HalfStep

 9: steppingModeStatusStripLabel.Text = "Step Mode: Half"

 10:  

 11: Case SteppingMode.HalfStep

 12: stepMode = SteppingMode.HighTorqueStep

 13: steppingModeStatusStripLabel.Text = "Step Mode: High Torque"

 14:  

 15: Case SteppingMode.HighTorqueStep

 16: stepMode = SteppingMode.SingleStep

 17: steppingModeStatusStripLabel.Text = "Step Mode: Single"

 18:  

 19: End Select

 20:  

 21: ElseIf (e.Button = MouseButtons.Left) Then

 22: 'Release the motor

 23: output = 0

 24: PortAccess.Output(888, output)

 25: decimalStatusStripLabel.Text = ("Decimal: " + output.ToString)

 26: binaryStatusStripLabel.Text = ("Binary: " + ConvertToBinary(output))

 27: End If

 28:  

 29: End Sub

Releasing the motor and letting it free-wheel is important, because I've noticed that stepper motors heat up very quickly. I don't know whether one can burn out a stepper motor or not, but the safest way to turn off the motor completely would be to disconnect its power supply.

Conclusion

We have reached the end of this article, but I sure hope it inspires you to start your own experiments with parallel port interfacing and programming. You can use this port to play with a lot of other things like LEDs, relays, etc. Over the last couple of months, I have been using my computer's parallel port for controlling several things, such as lights, fans, RC cars, robots and whatnot. There are things which could be extended, and added to this stepper motor project. You could, for example, use it as a web controlled camera panner. I have used mine as a camera panner which tracks moving objects using a webcam and lasers (video). Just remember that your imagination is the only limit. So, unleash your imagination and the sky is the limit. Have fun!

About the Author

Ashish Derhgawen is an IT student, currently living in New Delhi, India. He has been coding since fourth grade. Some of his other interests are harmonica playing, wildlife and cricket. When he’s not at school, he spends his time working on unusual projects related to robotics, webcams, and electronics besides others. You can reach Ashish through his blog at http://ashishrd.blogspot.com.