Jaspreet's Code Zone

Launch an Application at Windows Startup

2008-06-20T18:45:00.001+05:30

C#.Net

Introduction

There are a number of ways by which a program can be launched automatically at Windows startup. We can write the path and name of the program to autoexec.bat or use Win32 API functions to write to the Load= or Run= lines of Win.ini. But the better methods to do the same are to use the registry or the system's Startup folder.
The Startup folder method is easy to use as we just need to place a shorcut of the application we want to run, in the system's Startup folder. To prevent that application from running at startup we can simply remove its shortcut from the system's Startup folder.

To use the registry we need to write the startup information in a specific registry key. We can write a value entry to any of the following registry keys as per requirement:-

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run
Used to launch a program when a particular user logs in.
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnce
Used to launch a program the next time when a particular user logs in and then removes its value entry from the registry.
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run
Used to launch a program at system startup irrespective of the user who logs in.
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunOnce
Used to launch a program the next time when system starts and then removes its value entry from the registry.

I have used the above 4 registry keys to add/remove a program from system's Startup and developed a small library named "StartupApplication" to do so.

Using the Library "StartupApplication"

Below shown diagram is the class diagram for "SystemStartup" class defined in "StartupApplication" namespace.

In above class diagram you will see that "SystemStartup" class contains two nested classes "CurrentUser" and "AllUsers". Both these classes have two static methods "AddApplication" and "RemoveApplication".
To add a program to system's startup for a particular user we can use the following piece of code:-

SystemStartup.CurrentUser.AddApplication(
              "Name of the program",
              "Location of the program's exe file",
              SystemStartup.RunApplication.AlwaysAfterStartup
                                        );

To add a program to system's startup for all users just replcae "CurrentUser" with "AllUsers" in above code:-

SystemStartup.AllUsers.AddApplication(
              "Name of the program",
              "Location of the program's exe file",
              SystemStartup.RunApplication.AlwaysAfterStartup
                                      );

To remove a program from system's startup for a particular user we can use the following piece of code:-

SystemStartup.CurrentUser.RemoveApplication("Program Name");

To remove a program from system's startup for all users just replcae "CurrentUser" with "AllUsers" in above code:-

SystemStartup.AllUsers.RemoveApplication("Program Name");

One enumeration named "RunApplication" is also their in "SystemStartup" class as shown in its class diagram. This is used to specify Run or RunOnce feature of startup program.

Download StartupApplication Library Source Code
+
Demo Application

Functions Before & After main()

2008-06-12T12:27:00.000+05:30

C/C++

Functions Before & After main()
For this purpose compiler directive #pragma is used.

Syntax:
#pragma startup FUNCTION_NAME
#pragma exit FUNCTION_NAME

#pragma startup executes the function named FUNCTION_NAME before the main() function
pragma exit executes the function named FUNCTION_NAME after the main() function.

Function declaration of FUNCTION_NAME must be before startup and exit pragma directives and function and also it must not take any argument and return void.

The following code illustrates the use of #pragma startup & exit.

#include "iostream.h"
#include "conio.h"

void BeforeMain()
{
clrscr();
cout << "Function BeforeMain() Called.\n\n";
}

void AfterMain()
{
cout << "Function AfterMain() Called.\n\n";
getch();
}

#pragma startup BeforeMain
#pragma exit AfterMain

void main()
{
cout << "Function main() called.\n\n";
}

Output :-

Compiler Used - TURBO C++ Version 3.0

Download the source code and exe files from here.

Parallel Port User Control

2008-03-20T18:42:00.000+05:30

C#.Net

Introduction
A simple User Control developed in C#.Net used to control the Parallel Port.
The following tasks can be performed using it:-

Send data to Data Pins.
Receive data from Data Pins.
Send data to Control Pins.
Receive data from Control Pins.
Read current status of Status Pins.
Implement Synchronous and Asynchronous Loops.
Implement UP, DOWN and UP-DOWN Counters.

The below image shows the "HOME" of my User Control. Using this page, you can send or receive data from the DATA and the CONTROL registers of the Parallel Port. You can also check the current status of the STATUS Port.

The below image shows the "Loops" Page of my User Control. You can use this page to implement synchronous loops of desired time delay on the Parallel Port.

The below image shows the "Loops" Page of my User Control. You can use this page to implement asynchronous loops of desired time delay on the Parallel Port.

The below image shows the "Counters" Page of my User Control. You can use this page to implement binary counters (Up, Down, Up-Down) with desired time delay on the Parallel Port.

Background
I have used inpout32.dll for controlling parallel port. Using INPOUT32 I have made my own user control to control the Parallel Port in C#.Net. In my user control I have defined a class named "ParallelPort", in which all the methods and the properties discussed below are defined.

Using the code
Before using the code copy "ParallelPort.dll" to :-

"system32" folder if using XP ;
"winnt" folder if using Windows 2000 ;
"win98" folder if using Win98;

To use my Parallel Port User Control follow the steps written below:-

Make a "New Project" in Visual Studio. You use any language like C#, VB, J#, C++ etc.
Goto "Project" Menu, and click "Add Reference...".
In the "Add Reference" window, click the "Browse" tab and find "Jaspreets Parallel Port Control.dll" in the source code provided and then click "Ok".
Goto "Tools" Menu, and click "Choose ToolBox Items...".
In the "Choose ToolBox Items" window, find "ParallelPort" and click "Ok".
Now, you will see my user control in your toolbox. Drag n Drop it to the window form.
Press F5 to run the project.

But in case if you to use a different user interface then you can design your own interface and use the following methods and properties of "ParallelPort" class to control the Parallel Port:-

/***C#.NET CODE****/

/*
Create a new instance of ParallelPort class.
*/
ParallelPort PaPort = new ParallelPort();

/*
To set the Parallel Port address. 888 is decimal equivalent of 0x0378h.
*/
PaPort.PortAddress = 888;

PaPort.D0 = true; //To set D0 (Pin no. 2)
PaPort.D0 = false; //To reset D0 (Pin no. 2)

PaPort.D1 = true; //To set D1 (Pin no. 3)
PaPort.D1 = false; //To reset D1 (Pin no. 3)

PaPort.D2 = true; //To set D2 (Pin no. 4)
PaPort.D2 = false; //To reset D2 (Pin no. 4)

PaPort.D3 = true; //To set D3 (Pin no. 5)
PaPort.D3 = false; //To reset D3 (Pin no. 5)

PaPort.D4 = true; //To set D4 (Pin no. 6)
PaPort.D4 = false; //To reset D4 (Pin no. 6)

PaPort.D5 = true; //To set D5 (Pin no. 7)
PaPort.D5 = false; //To reset D5 (Pin no. 7)

PaPort.D6 = true; //To set D6 (Pin no. 8)
PaPort.D6 = false; //To reset D6 (Pin no. 8)

PaPort.D7 = true; //To set D7 (Pin no. 9)
PaPort.D7 = false; //To reset D7 (Pin no. 9)

PaPort.C0 = true; //To set C0 (Pin no. 1)
PaPort.C0 = false; //To reset C0 (Pin no. 1)

PaPort.C1 = true; //To set C1 (Pin no. 14)
PaPort.C1 = false; //To reset C1 (Pin no. 14)

PaPort.C2 = true; //To set C2 (Pin no. 16)
PaPort.C2 = false; //To reset C2 (Pin no. 16)

PaPort.C3 = true; //To set C3 (Pin no. 17)
PaPort.C3 = false; //To reset C3 (Pin no. 17)

/*
Returns true if input at S3 (Pin no. 10) is HIGH, else returns false.
*/
bool b = PaPort.S3;

/*
Returns true if input at S4 (Pin no. 11) is HIGH, else returns false.
*/
bool b = PaPort.S4;

/*
Returns true if input at S5 (Pin no. 12) is HIGH, else returns false.
*/
bool b = PaPort.S5;

/*
Returns true if input at S6 (Pin no. 13) is HIGH, else returns false.
*/
bool b = PaPort.S6;

/*
Returns true if input at S7 (Pin no. 15) is HIGH, else returns false.
*/
bool b = PaPort.S7;

/*
Returns the current status of all the Data Pins as an integer whose bits give the current status of each Data Pin (D0 to D7) with D0 being the LSB and D7 being the MSB.
*/
PaPort.ReadFromDataBus();

/*
Writes 123(or any other integer as provided in argument) to Data Pins.
*/
PaPort.WriteToDataBus(123);

PaPort.SetDataBus() //Sets all Data Pins.
PaPort.ResetDataBus() //Resets all Data Pins.

/*
Checks the current status of the Status Pins and assign value to S3-S7 accordingly.
*/
PaPort.UpdateStatusBus();

/*
Returns the current status of all the Status Pins (including the HIDDEN ones also) as an integer whose bits give the current status of each Status Pin (S0 to S7) with S0 being the LSB and S7 being the MSB.
*/
PaPort.ReadFromStatusBus() ;

/*
Returns the current status of all the Control Pins (including the HIDDEN ones also) as an integer whose bits give the current status of each Control Pin (C0 to C7) with C0 being the LSB and C7 being the MSB.
*/
PaPort.ReadFromControlBus() ;

/*
Writes 135(or any other integer as provided in argument) to Control Pins.
*/
PaPort.WriteToControlBus(135) ;

PaPort.SetControlBus() //Sets all Control Pins.
PaPort.ResetControlBus() //Resets all Control Pins.

/*
Loops from Pin D0 to Pin D7, setting the desired pin HIGH and all other LOW after a duration of 1000ms or 1sec.
*/
PaPort.StartSynchronousLoop(ParallelPort.Pin.D0, ParallelPort.Pin.D7, 1000, true);

/*
Loops from Pin D0 to Pin D7, setting the desired pin LOW and all other HIGH after a duration of 1000ms or 1sec.
*/
PaPort.StartSynchronousLoop(ParallelPort.Pin.D0, ParallelPort.Pin.D7, 1000, false);

/*
Loops through the pins specified by array LoopPins, setting the desired pin HIGH and all other LOW after a duration of 1000ms or 1sec.
*/
ParallelPort.Pin[] LoopPins = new ParallelPort.Pin[] {
ParallelPort.Pin.C1,
ParallelPort.Pin.D0,
ParallelPort.Pin.D3,
ParallelPort.Pin.C2,
ParallelPort.Pin.D1,
ParallelPort.Pin.D7,
ParallelPort.Pin.C1,
ParallelPort.Pin.D5
};
PaPort.StartAsynchronousLoop(LoopPins, 1000, true);

/*
Loops through the pins specified by array LoopPins, setting the desired pin LOW and all other HIGH after a duration of 1000ms or 1sec.
*/
ParallelPort.Pin[] LoopPins = new ParallelPort.Pin[] {
ParallelPort.Pin.C1,
ParallelPort.Pin.D0,
ParallelPort.Pin.D3,
ParallelPort.Pin.C2,
ParallelPort.Pin.D1,
ParallelPort.Pin.D7,
ParallelPort.Pin.C1,
ParallelPort.Pin.D5
};
PaPort.StartAsynchronousLoop(LoopPins, 1000, false);

PaPort.EndLoop(); //Stops all running LOOPs.

/*
Counts uptill 12 bits from 0 to 4096.
*/
PaPort.StartCounter(ParallelPort.CountBits._12,
ParallelPort.CounterType.UPCounter,1000);

PaPort.EndCounter(); //Stops all running COUNTERs.

/*
Returns true if Parallel Port is busy implementing LOOP or COUNTER Operation.
*/
PaPort.IsBusy;

/*
Resets all Data and Control Pins. Stops all running LOOPs and COUNTERs.
*/
PaPort.ResetAll();

EXE and Source Code Downloads

Download and install Microsoft .NET Framework Version 2.0.
Now download and install My Parallel Port Control Setup.
Download C#.Net source code.

Add-Subtract Two Integers

2008-03-08T09:03:00.001+05:30

C/C++

Add two integers
It is very easy to add two integers but the integers must be within a specified range ( like -32768 to 32767 in Turbo C++ ). But there is no restriction of range in my "ADD.cpp". You can add two integers of desired length as long as enough memory is available. Below is the snapshot of the "Add.exe" in which first two integers are entered by the user and their sum is then displayed.

Subtract two integers
The code for this is present in "Subtract.cpp". You can subtract integers of desired length as long as enough memory is available. Below is the snapshot of the "Subtract.exe" in which first two integers are entered by the user and their diffrence is then displayed.

Compiler Used - TURBO C++ Version 3.0

Download the source code and exe files from here.

"String" in TURBO C++

2008-03-07T19:18:00.000+05:30

C/C++

"String" in TURBO C++

'String' is a very useful keyword but it is not available in TURBO C++. So, I developed a small class named 'String' using which I can perform all the string related operations (as in other languages) in TURBO C++. The 'String' class is capable of performing almost all the string related functions like adding, searching, replacing, assigning, comparing, conversions etc. Below is the overview of 'String' class.

/*##########*/
/*String Class*/
/*##########*/

class String
{
char *wd ;
int Length;

public :

/*********CONSTRUCTORS*********/

/* CONSTRUCTOR 1 */
String (int len);

/* CONSTRUCTOR 2 */
String (const char ch);

/* CONSTRUCTOR 3 */
String (const char *sentence);

/* CONSTRUCTOR 4 */
String (const String *str);

/* COPY CONSTRUCTOR */
String (const String &str) ;

/**********DESTRUCTOR**********/

~String();

/*****OVERLOADED OPERATORS*****/

/* OVERLOADED ASSIGNMENT OPERATORS */
String& operator = (char ch);
String& operator = (const char *sentence);
String& operator = (const String &str);

/* OVERLOADED PRE-INCREMENT OPERATOR */
String& operator ++();

/* OVERLOADED POST-INCREMENT OPERATOR */
String operator ++(int Faltu);

/* OVERLOADED RELATIONAL OPERATORS */
bool operator == (const String str) const;

bool operator != (const String str) const;

bool operator > (const String str) const;

bool operator < (const String str) const; bool operator >= (const String str) const;

bool operator <= (const String str) const; /* OVERLOADED ASSIGNMENT & AIRTHMATIC OPERATORS */
void operator += (const String str);

String operator + (const String &str);

friend String operator + (const String &str1,const String &str2);

/* OVERLOADED EXTRACTOR OPERATOR */
friend ostream& operator << (ostream &outputStream,String &str) /* OVERLOADED INSERTOR OPERATOR */
friend istream& operator >> (istream &inputStream,String &str)

/* OVERLOADED SQUARE BRACKETS */
char& operator [] (int n) const;

/*******ASSIGN FUNCTION********/

/* Assign a substring of str starting at n that is l characters long
to the current string */
String& assign (const String &str,int n,int l);

/*******INSERT FUNCTION********/

/* Inserts the string str into the current string, at location n */
String& insert(const String &str,int n);

/******APPEND FUNCTIONS********/

/* Appends a substring of str starting at n that is l characters long
on to the end of the current string */
String& append (const String &str,int n,int l);

/* Appends n repititions of ch on to the end of the current string */
String& append (const String &str,int n);

/*******COMPARE FUNCTIONS******/

/* Compare a substring of str starting at n that is l characters long to the current string.Returns 0 if two strings are equal,-1 if first string is less than second string, else returns 1 */
int compare (const String &str,int n,int l);

/* Compare a substring of the string str to a substring of the current string,where n and l refer to str and nc and lc refer to current string. Returns 0 if two strings are equal,-1 if first string is less than second string, else returns 1 */
int compare (int nc,int lc,const String&,int n,int l);

/******ERASE FUNCTIONS*********/

/* Removes num characters from the current string, starting at index and returns *this */
String& erase(int index,int num);

/* Removes all characters from the current string, till it finds the character ch ,if not found then dosen't modifies the current string and returns *this */
String& erase_upto (const char &ch);

/* Removes all digits from the current string and returns *this */
String& erase_all_digits ();

/* Removes all isspace characters from the current string and returns *this */
String& erase_all_isspace_chars ();

/*****SUBSTRING FUNCTIONS******/

/* Returns a substring of the current string starting at n that is l characters long */
String substr(int n,int l);

/* Returns a substring of the current string starting from n'th character to m'th character */
String substr(char n,char m);

/* Removes a substring of the current string starting from n'th character to m'th character except the m'th character*/
String cut_substr(char n,char m);

/****FIND ONLY FUNCTIONS*******/

/* Returns the first occurrence of str within the current string, starting at index, -1 if nothing is found */
int find(const String &str,int index);

/* Returns the first occurrence of ch within the current string and num characters, starting at index, -1 if nothing is found */
int find(const String &str,int index,int num);

/* Returns the index of the first character within the current string that matches any character in str, beginning the search at index, -1 if nothing is found */
int find_first_of(const String &str,int index);

/* Returns the index of the first character within the current string that does not match any character in str, beginning the search at index, -1 if nothing is found */
int find_first_not_of(const String &str,int index);

/* Returns the index of the last character within the current string that matches any character in str, beginning the search at index, -1 if nothing is found */
int find_last_of(const String &str,int index);

/* Returns the index of the last character within the current string that does not match any character in str, beginning the search at index,-1 if nothing is found */
int find_last_not_of(const String &str,int index);

/***FIND AND MODIFY FUNCTIONS***/

/* Replaces the first occurence of src with dest if found, else the current string remains the same.Returns the modified string if found else returns a null string. */
String find_first_and_replace (const String &src,const String &dest);

/* Replaces all the occurences of src with dest if found, else the current string remains the same.Returns the modified string if found else returns a null string. */
String find_and_replace_all (const String &src,const String &dest);

/* Removes the first occurence of str if found, else the current string remains the same.Returns the modified string if found else returns a null string. */
String find_first_and_remove (const String &str);

/* Removes all the occurences of str if found, else the current string remains the same.Returns the modified string if found else returns a null string. */
String find_and_remove_all (const String &str);

/*****CONVERSION FUNCTIONS*****/

friend double strtodbl(const String &str)

friend String dbltostr(double dbl)

friend int strtoint(const String &str)

friend String inttostr(int x)

/****MISCELLANEOUS FUNCTIONS***/

/* TO MANUALLY DELETE CURRENT STRING */
void Delete();

/* Returns the length of the current string */
int length() const;

/* Returns a standard C character array version of my String */
char* c_str() const;

/* Returns true if the string has no elements, else returns false */
bool IsEmpty();

/* Removes all elements from the current string */
String& clear();

/* Swaps the current string with given string */
void swap(String &str);

/* Sort the current string */
String& sort ();

/* Copies characters from a string into an array ch, starting at n that is l characters long*/
int Copy_to_array (char *ch,int n,int l);

/* Reverses the current string */
friend String strrev (String &str)

/* Changes the current string characters to uppercase */
friend String strupr (String &str)

/* Changes the current string characters to lowercase */
friend String strlwr (String &str)

/* cin strings with white spaces in b/w */
friend void gets (String &str)

/* Prints a string */
friend void puts (String str)

protected :

String substr(char n,char m,int cut);
void ValidateIndex(int &index,int offset);

};

/*#################*/
/*End Of String Class*/
/*#################*/

I have placed the "String" class inside a header file named "j_string.h". You can download this header file from the link given at the end of this article or you can copy the below written code and save it as "j_string.h".

/*###########*/
/*J_STRING.H*/
/*###########*/


#ifndef __J_STRING_H
#define __J_STRING_H

#ifndef __IOSTREAM_H
#include "iostream.h"
#endif

#ifndef __CONIO_H
#include "conio.h"
#endif

#ifndef __STRING_H
#include "string.h"
#endif

#ifndef __CTYPE_H
#include "ctype.h"
#endif

#ifndef __STDIO_H
#include "stdio.h"
#endif

#ifndef __STDLIB_H
#include "stdlib.h"
#endif

#ifndef __MATH_H
#include "math.h"
#endif

#ifndef __J_BOOL_H
#include "j_bool.h"
#endif

class String
{
    char *wd ;
    int Length;

    public :

    /***************CONSTRUCTORS***********/

    /* CONSTRUCTOR 1 */
    String (int len);

    /* CONSTRUCTOR 2 */
    String (const char ch);

    /* CONSTRUCTOR 3 */
    String (const char *sentence);

    /* CONSTRUCTOR 4 */
    String (const String *str);

    /* COPY CONSTRUCTOR */
    String (const String &str) ;


    /***************DESTRUCTOR*************/

    ~String();


    /*********OVERLOADED OPERATORS*********/

    /* OVERLOADED ASSIGNMENT OPERATORS */
    String& operator = (char ch);
    String& operator = (const char *sentence);
    String& operator = (const String &str);

    /* OVERLOADED PRE-INCREMENT OPERATOR */
    String& operator ++();

    /* OVERLOADED POST-INCREMENT OPERATOR */
    String operator ++(int Faltu);

    /* OVERLOADED RELATIONAL OPERATORS */
    bool operator == (const String str) const;

    bool operator != (const String str) const;

    bool operator > (const String str) const;

    bool operator < (const String str) const;

    bool operator  >=  (const String str) const;

    bool operator <= (const String str) const;

    /* OVERLOADED ASSIGNMENT & AIRTHMATIC OPERATORS */
    void operator += (const String str);
    String operator + (const String &str);
    friend String operator + (const String &str1,const String &str2);

    /* OVERLOADED EXTRACTOR OPERATOR */
    friend ostream& operator << (ostream &outputStream,String &str)

    /* OVERLOADED INSERTOR OPERATOR */
    friend istream& operator >> (istream &inputStream,String &str)

    /* OVERLOADED SQUARE BRACKETS */
    char& operator [] (int n) const;


    /************ASSIGN FUNCTION***********/

    /* Assign a substring of str starting at n that is l characters long to the current string */
    String& assign (const String &str,int n,int l);


    /*************INSERT FUNCTION**********/

    /* Inserts the string str into the current string, at location n */
    String& insert(const String &str,int n);


    /*************APPEND FUNCTIONS*********/

    /* Appends a substring of str starting at n that is l characters long on to the end of the current string */
    String& append (const String &str,int n,int l);

    /* Appends n repititions of ch on to the end of the current string */
    String& append (const String &str,int n);


    /************COMPARE FUNCTIONS*********/

    /* Compare a substring of str starting at n that is l characters long to the current string.Returns 0 if two strings are equal,-1 if first string is less than second string, else returns 1 */
    int compare (const String &str,int n,int l);

    /* Compare a substring of the string str to a substring of the current string,where n and l refer to str and nc and lc refer to current string. Returns 0 if two strings are equal,-1 if first string is less than second string, else returns 1 */
    int compare (int nc,int lc,const String&,int n,int l);


    /**************ERASE FUNCTIONS*********/

    /* Removes num characters from the current string, starting at index and returns *this */
    String& erase(int index,int num);

    /* Removes all characters from the current string, till it finds the character ch ,if not found then dosen't modifies the current string and returns *this */
    String& erase_upto (const char &ch);

    /* Removes all digits from the current string and returns *this */
    String& erase_all_digits ();

    /* Removes all isspace characters from the current string and returns *this */
    String& erase_all_isspace_chars ();


    /************SUBSTRING FUNCTIONS*******/

    /* Returns a substring  of the current string starting at n that is l characters long */
    String substr(int n,int l);

    /* Returns a substring of the current string starting from n'th character to m'th character */
    String substr(char n,char m);

    /* Removes a substring of the current string starting from n'th character to m'th character except the m'th character*/
    String cut_substr(char n,char m);


    /***********FIND ONLY FUNCTIONS********/

    /* Returns the first occurrence of str within the current string, starting at index, -1 if nothing is found */
    int find(const String &str,int index);

    /* Returns the first occurrence of ch within the current string and num characters, starting at index, -1 if nothing is found */
    int find(const String &str,int index,int num);

    /* Returns the index of the first character within the current string that matches any character in str, beginning the search at index, -1 if nothing is found */
    int find_first_of(const String &str,int index);

    /* Returns the index of the first character within the current string that does not match any character in str, beginning the search at index, -1 if nothing is found */
    int find_first_not_of(const String &str,int index);

    /* Returns the index of the last character within the current string that matches any character in str, beginning the search at index, -1 if nothing is found */
    int find_last_of(const String &str,int index);

    /* Returns the index of the last character within the current string that does not match any character in str, beginning the search at index,-1 if nothing is found */
    int find_last_not_of(const String &str,int index);


    /*********FIND AND MODIFY FUNCTIONS**************/

    /* Replaces the first occurence of src with dest if found, else the current string remains the same.Returns the modified string if found else returns a null string. */
    String find_first_and_replace (const String &src,const String &dest);

    /* Replaces all the occurences of src with dest if found, else the current string remains the same.Returns the modified string if found else returns a null string. */
    String find_and_replace_all (const String &src,const String &dest);

    /* Removes the first occurence of str if found, else the current string remains the same.Returns the modified string if found else returns a null string. */
    String find_first_and_remove (const String &str);

    /* Removes all the occurences of str if found, else the current string remains the same.Returns the modified string if found else returns a null string. */
    String find_and_remove_all (const String &str);


    /***********CONVERSION FUNCTIONS*******/

    friend double strtodbl(const String &str)

    friend String dbltostr(double dbl)

    friend int strtoint(const String &str)

    friend String inttostr(int x)


    /**********MISCELLANEOUS FUNCTIONS***************/

    /* TO MANUALLY DELETE CURRENT STRING */
    void Delete();

    /* Returns the length of the current string */
    int length() const;

    /* Returns a standard C character array version of my String */
    char* c_str() const;

    /* Returns true if the string has no elements, else returns false */
    bool IsEmpty();

    /* Removes all elements from the current string */
    String& clear();

    /* Swaps the current string with given string */
    void swap(String &str);

    /* Sort the current string */
    String& sort ();

    /* Copies characters from a string into an array ch, starting at n  that is l characters long*/
    int Copy_to_array (char *ch,int n,int l);

    /* Reverses the current string */
    friend String strrev (String &str)

    /* Changes the current string characters to uppercase */
    friend String strupr (String &str)

    /* Changes the current string characters to lowercase */
    friend String strlwr (String &str)

    /* cin strings with white spaces in b/w */
    friend void gets (String &str)

    /* Prints a string */
    friend void puts (String str)

    protected :

    String substr(char n,char m,int cut);
    void ValidateIndex(int &index,int offset);

};

/*************CONSTRUCTORS***********/

String :: String(int len = 0)
{
    Length = len;
    wd = new char[len+1];
    wd[len] = '\0';
    *wd = '\0';
}

String :: String(const char ch)
{
    *this = ch;
}

String :: String(const char *sentence)
{
    *this = sentence;
}

String :: String(const String* str)
{
    *this = *str;
}

String :: String(const String& str)
{
    *this = str;
}

/*************DESTRUCTOR*************/

String :: ~String()
{
    delete wd;
}

/*******OVERLOADED OPERATORS*********/

String& String :: operator = (char ch)
{
    Length = 1;
    wd = new char[Length+1];
    wd[0] = ch;
    wd[1] = '\0';
    return *this;
}

String& String :: operator = (const char *ch)
{
    Length = strlen(ch);
    wd = new char[Length+1];
    strcpy(wd,ch);
    return *this;
}

String& String :: operator = (const String& str)
{
    Length = strlen(str.wd);
    wd = new char[Length+1];
    strcpy(wd,str.wd);
    return *this;
}

String& String :: operator ++ ()
{
    ++(this->wd);
    return *this;
}

String String :: operator ++ (int a)
{
    a = a;
    String temp = *this;
    (this->wd)++;
    return temp;
}

bool String :: operator == (const String str) const
{
    return strcmp(wd,str.wd) == 0 ? true : false ;
}

bool String :: operator != (const String str) const
{
    return strcmp(wd,str.wd) == 0 ? false : true ;
}

bool String :: operator > (const String str) const
{
    return strcmp(this->wd,str.wd) > 0  ? true : false ;
}

bool String :: operator < (const String str) const
{
    return strcmp(this->wd,str.wd) < 0 ? true : false ;
}

bool String :: operator  >=  (const String str) const
{
    return *this > str?true:*this == str ? true : false;
}

bool String :: operator <= (const String str) const
{
    return *this < str?true:*this == str ? true : false;
}

void String :: operator += (const String str)
{
    *this = *this + str;
}

String String :: operator + (const String &str)
{
    String Temp( Length + str.Length );
    strcpy(Temp.wd,wd);
    strcat(Temp.wd, str.wd);
    return Temp;
}

String operator + (const String &str1,const String &str2)
{
    String temp = str1;
    return temp.operator+(str2);
}

ostream& operator << (ostream &outputStream,String &str)
{
    outputStream << str.wd;
    return outputStream;
}

istream& operator >> (istream &inputStream,String &str)
{
    char *p;
    inputStream >> p;
    str = p;
    return inputStream;
}

char& String :: operator [] (int n) const
{
    return wd[n];
}

/*********ASSIGN FUNCTION************/

String& String:: assign (const String &str,int index,int len)
{
    ValidateIndex(index,str.length());
    ValidateIndex(len,str.length());
    String temp = str;
    temp.erase(0,index);
    temp[len] = '\0';
    *this = temp;
    return *this;
}

/********INSERT FUNCTION*************/

String& String:: insert(const String &str,int x)
{
    ValidateIndex(x,Length);
    if(x==0)
    {
        *this = str + *this;
        return *this;
    }
    String cpy;
    cpy.assign(*this,x,Length);
    this->assign(*this,0,x);
    *this = *this + str;
    *this+=cpy;
    return *this;
}

/********APPEND FUNCTIONS************/

String& String:: append (const String &str,int index,int len)
{
    ValidateIndex(index,str.length());
    ValidateIndex(len,str.length());
    int n = index+len;
    for ( index; index < n; index++)
    *this = *this + str[index];
    return *this;
}

String& String:: append (const String &str,int num)
{
    for (int i=1;i <= num;i++)
    *this = *this + str;
    return *this;
}

/*******COMPARE FUNCTIONS************/

int String :: compare (const String &str,int n,int l)
{
    String temp;
    temp.assign (str,n,l);
    return *this < temp?-1:*this > temp?1:0;
}

int String :: compare (int nc,int lc,const String &str,int n,int l)
{
    String temp,tempc;
    temp.assign (str,n,l);
    tempc.assign (*this,nc,lc);
    return tempc < temp?-1:tempc > temp?1:0;
}

/********ERASE FUNCTIONS*************/

String& String:: erase (int n,int l)
{
    if(*this=="")
    {
        return *this;
    }

    if(n < 0)
    {
        n = 0;
    }

    if (n+l  >=  Length)
    {
        this->assign(*this,0,n);
    }
    else
    {
        String temp = *this;
        int nd = n + l;
        for (n,nd;n < Length;n++,nd++)
        temp[n] = temp[nd];
        *this = temp;
    }
    return *this;
}

String& String:: erase_upto (const char &ch)
{
    String temp = *this;
    for (int n=0;n < Length;n++)
    if(temp[n] == ch)
    break;
    temp.erase(0,n);
    if(n < Length)
    *this = temp;
    return *this;
}

String& String:: erase_all_digits ()
{
    String temp;
    temp = *this;
    for (int n=0;n < Length;n++)
    {
        if(isdigit(temp[n]))
        {
            temp.erase(n,1);
            n--;
        }
    }
    *this = temp;
    return *this;
}

String& String:: erase_all_isspace_chars ()
{
    String temp;
    temp = *this;
    for (int n=0;n < Length;n++)
    {
        if(isspace(temp[n]))
        {
            temp.erase(n,1);
            n--;
        }
    }
    *this = temp;
    return *this;
}

/******SUBSTRING FUNCTIONS***********/

String String:: substr(int index,int num)
{
    ValidateIndex(index,Length);
    ValidateIndex(num,Length);
    String temp;
    if( index+num > Length)
    temp.assign(*this,index,Length);
    else
    temp.assign(*this,index,num);
    return temp;
}

String String:: substr(char n,char m)
{
    String temp;
    temp = this->substr(n,m,0);
    return temp;
}

String String:: cut_substr(char n,char m)
{
    String temp;
    temp = this->substr(n,m,1);
    return temp;
}

/*********FIND FUNCTIONS*************/

int String:: find(const String &str,int index=0)
{
    ValidateIndex(index,Length);
    int c,count = 0;
    for (index; index < Length ;index++)
    {
        if (wd[index] == str[0])
        {
            c = index;
            for (int j=0; j < str.length();j++,c++)
            if (wd[c] == str[j])
            count++;
            if (count == str.length())
            return index;
            count = 0;
        }
    }
    return -1;
}

int String:: find(const String &str,int index,int num)
{
    ValidateIndex(index,Length);
    ValidateIndex(num,Length);
    int c,count=0,flag=-1;
    int len_a = str.length();
    int nd = index+num-1;
    for (index; index <= nd;index++)
    {
        if (wd[index] == str[0])
        {
            c = index;
            for (int j=0; j < len_a;j++,c++)
            if (wd[c] == str[j])
            count++;
            if (count == len_a)
            flag = index;
            if (count != len_a)
            count = 0;
        }
    }
    return flag;
}

int String:: find_first_of(const String &str,int index=0)
{
    ValidateIndex(index,Length);
    int count = 0;
    for (index; index <= Length-1;index++)
    for (int i=0;i <= str.Length-1;i++)
    {
        if (wd[index] != str.wd[i])
        {
            count = 0;
            break;
        }
        else
        {
            int c = index;
            for (int j=0; j < str.Length;j++,c++)
            if (wd[c] == str.wd[j])
            count++;
            if(count==str.Length)
            return index;
        }
    }
    return -1;
}

int String:: find_first_not_of(const String &str,int index=0)
{
    ValidateIndex(index,Length);
    int count = 0;
    for (index; index <= Length-1;index++)
    {
        for (int i=0;i <= str.Length-1;i++)
        {
            if (wd[index] == str.wd[i])
            {
                count = 0;
                break;
            }
            count++;
        }
        if(count==str.Length)
        return index;
        continue;
    }
    return -1;
}

int String:: find_last_of(const String &str,int index=0)
{
    ValidateIndex(index,Length);
    int count = 0;
    String temp,temp1;
    temp = *this;
    temp1 = str;
    strrev(temp);
    strrev(temp1);
    for (index; index <= temp.Length-1;index++)
    for (int i=0;i <= temp1.Length-1;i++)
    {
        if (temp.wd[index] != temp1.wd[i])
        {
            count = 0;
            break;
        }
        else
        {
            int c = index;
            for (int j=0; j < temp1.Length;j++,c++)
            if (temp.wd[c] == temp1.wd[j])
            count++;
            if(count==temp1.Length)
            return temp.Length-index-temp1.Length;
        }
    }
    return -1;
}

int String:: find_last_not_of(const String &str,int index=0)
{
    ValidateIndex(index,Length);
    int count = 0;
    String temp,temp1;
    temp = *this;
    temp1 = str;
    strrev(temp);
    strrev(temp1);
    for (index; index <= temp.Length-1;index++)
    {
        for (int i=0;i <= str.Length-1;i++)
        {
            if (temp.wd[index] == str.wd[i])
            {
                count = 0;
                break;
            }
            count++;
        }
        if(count==str.Length)
        return temp.Length-index;
        continue;
    }
    return -1;
}

/************FIND AND MODIFY FUNCTIONS*********/

String String:: find_first_and_replace (const String &src,const String &dest)
{
    int index = 0;
    if( ( index = this->find(src) ) == -1)
    return *this;
    String Pre,Post;
    Pre.assign(*this,0,index);
    Post.assign(*this,index+src.length(),Length);
    *this = Pre + dest + Post;
    return *this;
}

String String:: find_and_replace_all (const String &src,const String &dest)
{
    if( src == dest )
    return *this;

    int index = 0;
    String temp,temp1 = *this,temp2;
    while( (index = temp1.find(src) ) != -1)
    {
        temp2.assign(temp1,0,index);
        temp = temp + temp2 + dest;
        temp1.erase(0,index);
        temp1.find_first_and_remove(src);
    }
    if(temp == '\0')
    temp = *this;
    *this = temp;
    return temp;
}

String String:: find_first_and_remove (const String &str)
{
    int index = 0;
    if( ( index = this->find(str) ) == -1)
    return *this;
    String Pre = "" , Post = "";
    Pre.assign(*this,0,index);
    Post.assign(*this,index+str.length(),Length);
    *this = Pre + Post;
    return *this;
}

String String:: find_and_remove_all (const String &str)
{
    while(this->find(str) != -1)
    find_first_and_remove(str) ;
    return *this;
}

/***************CONVERSION FUNCTIONS***********/

double strtodbl(const String &str)
{
    double dbl;
    dbl = strtod( str.c_str(), NULL);
    return dbl;
}

String dbltostr(double dbl)
{
    char *str;
    int dec, sign, ndig = 5;
    str = fcvt(dbl, ndig, &dec, &sign);
    String temp = str;
    temp.insert('.',dec);
    if(sign == 1)
    temp = '-' + temp;
    return temp;
}

int strtoint(const String &str)
{
       return (int)strtodbl(str);
}

String inttostr(int x)
{
    char *str;
    int dec, sign, ndig = 5;
    str = fcvt((double)(x), ndig, &dec, &sign);
    String temp = str;
    temp.erase(dec,temp.length());
    if(sign == 1)
    temp = '-' + temp;
    return temp;
}

/***************MISCELLANEOUS FUNCTIONS*********/

void String :: Delete()
{
    delete wd;
}

int String :: length() const
{
    return Length;
}

char* String :: c_str() const
{
    return this->wd;
}

bool String :: IsEmpty()
{
    String temp;
    return *this==temp?true:false;
}

String& String :: clear()
{
    String temp;
    *this = temp;
    return *this;
}

void String ::swap(String &str)
{
    String temp;
    temp = *this;
    *this = str;
    str = temp;
}

String& String:: sort ()
{
    for (int i=0; i <= Length-2;i++)
    for (int j=i+1; j <= Length-1;j++)
    if (wd[i] < wd[j])
    {
        char temp;
        temp = wd[i];
        wd[i] = wd[j];
        wd[j] = temp;
    }
    strrev(*this);
    return *this;
}

int String :: Copy_to_array (char *ch,int l,int n=0)
{
    String temp;
    temp.assign (*this,n,l);
    strcpy(ch,temp.wd);
    return l;
}

String strrev(String &str)
{
    strrev(str.wd);
    return str;
}

String strupr(String &str)
{
    strupr(str.wd);
    return str;
}

String strlwr(String &str)
{
    strlwr(str.wd);
    return str;
}

void gets( String &str )
{
    char *cp = new char[100001];
    int i = 0;
    char key;
    while(1)
    {
        key = getch();
        if(key == '\r')
        {
            cp[i] = '\0';
            break;
        }
        if ( key == '\b' && i != 0)
        {
            i--;
            cout << '\b' << " " << '\b';
        }
        else
        {
            cp[i]=key;
            i++;
            cout << key;
        }
    }
    str = cp;
    delete cp;
    cout << endl;
}

void puts( String str )
{
    cout << str;
}

/******PROTECTED FUNCTIONS***********/

String String:: substr(char n,char m,int cut)
{
    String temp;
    int start = 0,last = 0;
    if( (start = this->find(n,0) ) == -1 )
    start = 0;
    if( (last = this->find(m,start+1) ) == -1 )
    last = Length;
    temp = this->substr(start,last-start);
    if(cut == 1)
    this->erase(start,last-start);
    return temp;
}

void String:: ValidateIndex(int &index,int offset = 0)
{
    if( index < 0 )
    index = 0;
    if( index > offset )
    index = offset;
}

#endif

/*#################*/
/*End Of J_STRING.H*/
/*#################*/

Using the 'String' Class

To use the class see the code below:-

Output:-

Compiler Used - TURBO C++ Version 3.0

Download the source code and exe files from here.

IC ULN 2803 Pinout & Working

2008-02-24T09:35:00.001+05:30

Introduction

IC ULN2803 consists of octal high voltage, high current darlington transistor arrays. The eight NPN Darlington connected transistors in this family of arrays are ideally suited for interfacing between low logic level digital circuitry (such as TTL, CMOS or PMOS/NMOS) and the higher current/voltage requirements of lamps, relays, printer hammers or other similar loads for a broad range of computer, industrial, and consumer applications.

Features

Eight Darlingtons with Common Emitter.
Open–collector outputs.
Free wheeling clamp diodes for transient suppression.
Output Current to 500 mA.
Output Voltage to 50 V.
Inputs pinned opposite outputs to simplify board layout.

Pinout

Working

The ULN 2803 IC consists of eight NPN Darlington connected transistors (often called a Darlington pair). Darlington pair consists of two bipolar transistors such that the current amplified by the first is amplified further by the second to get a high current gain β or h_FE. The figure shown below is one of the eight Darlington pairs of ULN 2803 IC.

Now 2 cases arise:-

Case 1: When IN is 0 volts.

Q1 and Q2 both will not conduct as there is no base current provided to them. Thus, nothing will appear at the output (OUT).

Case 2: When IN is 5 volts.

Input current will increase and both transistors Q1 and Q2 will begin to conduct. Now, input current of Q2 is combination of input current and emitter current of Q1, so Q2 will conduct more than Q1 resulting in higher current gain which is very much required to meet the higher current requirements of devices like motors, relays etc. Output current flows through Q2 providing a path (sink) to ground for the external circuit that the output is applied to. Thus, when a 5V input is applied to any of the input pins (1 to 8), output voltage at corresponding output pin (11 to 18) drops down to zero providing GND for the external circuit. Thus, the external circuit gets grounded at one end while it is provided +V_cc at its other end. So, the circuit gets completed and starts operating.

DataSheet

Download ULN2803 datasheet- Link 1
Download ULN2803 datasheet- Link 2

Use of # and ##

2008-01-25T16:46:00.000+05:30

C/C++

Use of # and ##

# (Pound Sign) is used as operators to perform token replacement and ## (Double Pound Sign) is used as operators to perform merging during the preprocessor scanning phase.
The following code illustrates the use of # and ##.

#include <iostream.h>                                                          #include <conio.h>                                                                                                                                                                                                                                               #define Display(s)  cout << #s                                                     #define _Display(x,y)  cout << x##y                                                  void main()                                                                            {                                                                                                                                                    clrscr();                                                                         char *xy = " JASPREET SINGH KALEKA";                                                                                                   Display(HELLO! MY NAME IS);                                                  _Display(x,y);                                                                   getch();                                                                          }

Output :-

Compiler Used - TURBO C++ Version 3.0

Download the source code and exe files from here.

Display All 256 Keyboard Characters (ASCII)

2008-01-25T15:52:00.000+05:30

C/C++

ASCII characters - This is the set familiar from the dawn of computing; all of these characters correspond to keyboard keys.

0-31 are control characters.
32 is the space.
48-57 are numbers.
65-90 are upper-case letters.
97-122 are lower-case letters.
Rest are punctuation and symbols.

The code is used to display all these keyboard characters by using key combinations like CTRL+ PA , ALT+253 etc.
Note:-
Some of the characters are not displayable like \a (or Beep,
used to produce a beep sound) , \b (or Backspace) etc.
Below are some of the displayable characters shown.

Compiler Used - TURBO C++ Version 3.0

Download the source code and exe files from here.

Sum Of Digits

2008-01-23T15:15:00.000+05:30

C/C++

Sum Of Digits
The following code is used to find the sum of digits of a number.

#include <iostream.h>                                                   #include <conio.h>                                                                                                                     void main()                                                                               {                                                                                                 clrscr();                                                                                        long n,num;                                                                                            cout << "Enter a number -> ";                                                                                                                                                                         cin >> n;                                                                           cout << "\n\nSum of digits of " << num << " is -> ";                                cout<< ((num=n,n=(n-1)%9+1)<0?-n:n);                                                           getch();                                                                          }

Output :-

Compiler Used - TURBO C++ Version 3.0

Download the source code and exe files from here.

Interfacing RELAYs using the Parallel Port

2008-01-14T19:06:00.000+05:30

If you haven't read my previous article "Basics of Parallel Port" then I would suggest you to read it first.

Introduction

In this article I will first tell you about how to build the Relay interface circuit for the Parallel Port and then how to control the circuit using software. With this very basic prototype you will be able to learn a lot how the parallel port works, how a relay works and the use of ULN2803 IC. So, I'll start with the circuit first.

Circuit Diagram

Circuit Description

Components Used:-

One 12V Relay
IC ULN2803
12V power supply
DB-25 Male Connector
Light Bulb
Zero PCB
Ribbon Wire

Connect the data pins(2 to 9) of the parallel port to pins 1 to 8 of ULN2803 IC.
Connect GND pin 25 of the parallel port to pin 9 of ULN2803 IC.
Connect one side of Relay coil to pin 10 and other side to pin 18 of ULN2803 IC.
Connect a bulb between common terminal of relay and neutral AC wire.
Connect the live AC wire to normally open terminal of relay.
Connect +ve terminal of power supply to pin 10 and -ve terminal to pin 9.
Your circuit is now complete.

Note - For 12 V power supply I have used the power supply of my computer system. Power supply of a PC has got 4 terminals, of which 2 are GND and the other 2 are +5V and +12V. I have used one GND and +12V terminal to give power supply to ULN2803 IC.

How the circuit works?

The circuit consists of two main parts - ULN2803 IC and a 5 pin Relay. Working of both of them is explained below:-

Working of Relay

A relay is an electrically operated switch. It allows one circuit to switch a second circuit which is completely separated from the first. For example a low voltage battery circuit can use a relay to switch a 230V AC mains circuit. There is no electrical connection inside the relay between the two circuits, the link is magnetic and mechanical.

In the above figure, when controlling switch is closed, current flows through the coil and thus, magnetic field is produced. The resulting magnetic field attracts an armature that is mechanically linked to a set of contacts. The movement makes a connection with a fixed contact and circuit gets completed. When the current to the coil is switched off, the armature is returned by a force approximately half as strong as the magnetic force to its relaxed position and the connection is broken.

The relay's switch connections are usually labeled COM, N/C and N/O:

COM = Common, always connect to this, it is the moving part of the switch.
N/C = Normally Closed, COM is connected to this when the relay coil is off.
N/O = Normally Open, COM is connected to this when the relay coil is on.

Connect to COM and N/O if you want the switched circuit to be on when the relay coil is on.
Connect to COM and N/C if you want the switched circuit to be on when the relay coil is off.

Working of ULN2803 IC

For working of ULN2803 click here.

Circuit Working

Working of this circuit is very simple. When data at pin 2 is '1', i.e., when 5V is coming out of pin 2 then, pin 1 of ULN2803 IC receives 5V input and thus its pin 18 provides GND to one end of relay coil. The other end of relay coil is given +Vcc (12V), so the coil gets energized and the COM gets connected to the N/O contact and the AC mains circuit gets completed and the bulb glows.
Now, bulb will glow as long as data at pin 2 is high. When data at pin 2 becomes low, then the GND provided by pin 18 of ULN2803 IC vanishes and coil gets de-energized and thus COM is connected back to N/C contact. Thus, external AC mains circuit is broken and bulb stops glowing.

Software

To control any port we need a kernel mode driver software. Softwares generally run in USER mode. But to control the Parallel Port we need a software running in kernel mode. I have used C#.Net for developing this software.

Download and install Microsoft .NET Framework Version 2.0.
Now download and install My Parallel Port Control Setup.
Download C#.net source code.

For more info on software click here.

Interfacing LEDs using the Parallel Port

2007-12-27T11:33:00.000+05:30

If you haven't read my previous article "Basics of Parallel Port" then I would suggest you to read it first.

Introduction

In this article I will first tell you about how to build the LED interface circuit for the Parallel Port and then how to control the circuit using software. With this very basic prototype you will be able to learn a lot how the parallel port works. So, I'll start with the circuit first.

Circuit Diagram

Circuit Description

Components Used:-

Eight RED colored LEDs
DB-25 Male Connector
Zero PCB
Ribbon Wire

All you need to do is to connect each data pin from the parallel port (pins 2 to 9) to positive terminal of a LED and one ground pin (any one from 18 to 25) to the negative terminal of all the LEDs.
Since LEDs have polarity, you should pay attention to correctly locate its positive and negative terminals. If you pay close attention, you will see that LEDs are not completely rounded, the cathode side is a little bit flat. Also the longer leg of LED is anode or positive terminal and the shorter leg is cathode or negative terminal.

How the circuit works?

Working of this circuit is pretty simple. When data at any pin 2 - 9 is '1' , that particular LED will glow, else if data is '0', the LED will stop glowing.

When data at any pin from 2 - 9 is '1',then it means that 5 volts is coming out of that pin and is going towards +ve terminal of LED. Circuit gets completed through ground pin (any from 18 to 25) and the LED glows until data at that particular pin is not '0'.

This data flow is controlled using software discussed below.

Software

To control any port we need a kernel mode driver software. Softwares generally run in USER mode. But to control the Parallel Port we need a software running in kernel mode. I have used C#.Net for developing this software.

Download and install Microsoft .NET Framework Version 2.0.
Now download and install My Parallel Port Control Setup.
Download the source code in C#.Net.

For more info on software click here.

In The End

This article was just an building block to the parallel port interfacing.

Now you are ready to make your second parallel port controlled device. Read my next article on Interfacing RELAYs using the Parallel Port.

Introduction To Parallel Port

2007-12-16T07:59:00.000+05:30

What is a port?
A port contains a set of signal lines that the CPU sends or receives data with other components. We use ports to communicate via modem, printer, keyboard, mouse etc. In signaling, open signals are "1" and close signals are "0" so it is like binary system. A Standard Parallel Port sends 8 bits and receives 5 bits at a time. The serial port RS-232 sends and receive 1 bit at a time.

About Parallel Port
The Parallel Port is the easiest way to control devices outside the PC, like LEDs, lights and even home appliances. In fact the idea behind parallel port is really simple. It is an 8-bit parallel interface, so we have eight bits available there. Simple put, since each data bit can be set as either “0” (“turned off”) or “1” (“turned on”), we can directly turn on or off up to eight devices.

Parallel Port has mainly 3 modes of operation :-

SPP - Standard Parallel Port (Discussed in this article).
EPP - Enhanced Parallel Port (Not discussed in this article).For more info on EPP click here.
ECP - Extended Capabilities Port (Not discussed in this article).For more info on ECP click here.

How it looks?
On the PC the parallel port uses a 25-pin connector (called DB-25, 25-pin D-sub or 25-pin D-shell), as you can see in figure shown below.

Pin Configuration
The Parallel Port actually has 32 pins.

8 - Data Pins (shown in yellow)
8 - Control Pins (shown in red)
8 - Status Pins (shown in blue)
8 - Ground Pins (shown in green)

But only 25 pins were required to run a printer through it, so rest of the pins (not shown in above picture) were not made available outside the mother board.
So, we have in total 25 pins.

8 - Data Pins
4 - Control Pins
5 - Status Pins
8 - Ground Pins

Data Pins
Data pins are used to send 8-bits of data. Pins 2 to 9 are data pins or we can call them as an 8-bit data bus (D0 – D7). This data bus carries 8-bit data at any instant of time as shown below.

The type of data it carries is in digital form, i.e. either 0 or 1.

‘0’ means OFF or 0 volts.
‘1’ means ON or 5 volts.

For example, if pin 2 is carrying ‘0’, then it will give 0 volts at output. And if it is carrying ‘1’, then it will give 5 volts at its output. Similarly we get output as 0 volts or 5 volts from other data pins.

Now a question arises, how can we send data?

Answer to this is pretty simple. Every port on our computer has got some unique hexadecimal address. Parallel Port also has got a specific address. Generally this address is 0x378H.

To find out the address of the parallel port on your computer follow the steps written below:-

Open Device Manager.
Go to Ports (COM & LPT) item in it.
Double click ECP Printer Port (LPT1).
A new window will pop up.
In that window click Resources tab.
Now see the I/O Range. Mine is 0378–037F.
Here 0378 is the starting address of the Parallel Port.

Now we can send data using software programs (discussed later) to this address.

Now we know where to send data, but what data we have to send?

We have to send ‘0’ or ‘1’ to each pin (D0-D7) simultaneously.

Each Data Pin has been assigned a bit value as shown below.

Here, D7 is the most significant bit and D0 is the least significant bit.

This means, if we send any data say ‘16’ , then ‘1’ will be sent to D4 and ‘0’ to rest of the pins. Similarly ‘255’ will send ‘1’ to each pin.

We can also view it like this:-

Binary representation of 16 is 00010000.
Binary representation of 255 is 11111111.

See the table below for other decimal numbers.

So, every data is converted to 8-bit binary form and pins are send data accordingly.

Status Pins
These ports are made for reading signals. The range is like in data ports which are S0-S7. But S0, S1, S2 are invisible in the connector. And the address for this is 0x379.

Note- Address of data bus is same as that of parallel port. But address of Status Bus is 0x378 + 1, i.e. 0x379 (Address of Data Bus + 1).

Bit value for these is shown below.

Control Pins
This port usually used for sending as well as recieving data. The range is like in data ports C0-C7 but C4, C5, C6, C7 are invisible in connector. And the address for this is 0x37A.

Note- Address of Control Bus is 0x378 + 2, i.e. 0x37A (Address of Data Bus + 2).

Ground Pins
These pins are just used to complete the circuit attached to the parallel port.

In The End
This article was just an introduction to the parallel port.

Now you are ready to make your first parallel port controlled device. Read my next article on Interfacing LEDs using the Parallel Port.