Arrange LEDs as matrix

MXLED is a simulator of the circuit matrix of LEDs. With this simulator, we can try to program the LED matrix controllers even without the hardware. MXLED made LED matrix by arranging the LEDs on the vertical lines and horizontal lines. We must provide the number of rows of horizontal lines (we make eight lines). Then, we also make as many vertical lines of columns. Arrangement of vertical lines and horizontal images are as follows:

Vertical and Horizontal Line

Lines of vertical and horizontal are not connected. Then, at each meeting point between the vertical and horizontal lines, attach a LED by connecting its anode to the horizontal lines and its cathode to the vertical lines. Installation of these LEDs are as shown below:

Installation of LEDs

By installing LEDs as above, the light up LED is the LED where the anode is connected to the horizontal lines which is high (1) and the cathode is connected to the vertical lines which is low (0). There is only one low vertical line at a time, while other line must be kept high. This low vertical line we refer to as the active column. Unlike the vertical lines, horizontal lines consisting of eight lines may has high or low value without having to pay attention to the other horizontal lines.

Horizontal Control

To give the voltage on this horizontal line, we can not directly connect it to port. This is caused by the need for large electrical currents. Therefore, horizontal lines are the powered using a PNP transistor as shown below:

The power supply for the horizontal lines

Each horizontal line given a transistor like the picture above. In this way, to make the horizontal lines can give the current to the LED, then the base must be low state (0). Meanwhile, if the base was given a high state, then the line could not provide current to the LED.

Vertikal Control

As horisontol lines, vertical lines can not be controlled directly using the port. This is caused by the large amount of current that must be sunk into the ground. Therefore, we can use the NPN transistor to sink current from these vertical lines. Way of installation is as shown below:

Vertical line current sink

Each vertical line is controlled using a transistor as shown above. If the base was given a high condition (1), then the line (column) will be an active line. Conversely, if the base were given the condition of low (0), then the line becomes inactive column.

As already mentioned above, there is only one column that should be active, while the other columns must be inactive. There are many ICs that output works like that. One of the cheapest is the 4017.

Columns control using IC 4017

Too bad that this IC only has 10 outputs. Thus, we can only make the controls to 10 columns

Relax, we can use other tricks to extend the control capabilities of this 4017. The trick is to make the block columns. The columns are grouped into block of columns. Each block columns consists of 10 columns. The columns in each block columns are numbered from 0 to 9. So, column 0 is the column 0 of block 0, column 10 is the column 0 of block 1, column 21 is column 1 of block 2, and so on.

Each base of the column with the same number are combined into one and is controlled by an output of 4017. For example, the base of the column 0 is connected to the base of the column 10, column 20, column 30, and so on. Then the bases which have become one, controlled by the Q0 of 4017.

Block Columns

From the picture above, we can see that although the base of column 0 and column 10 are controlled concurrently, but the column that can sink current is only the column with the active block. Seen that way of controlling the “column” or “block columns” is the same. If the number of block columns is only a few, then the controlling block of columns can be done directly using the port of the microcontroller. However, if the number of block columns is quite a lot, then the block columns can also be controlled using the other 4017. So, we develop a multilevel 4017, ie 4017 units (control column) and 4017 tens (the controlling block of columns). And if the number of block columns more than 10, then we can make the next level, ie 4017 level in the hundreds.

To cascade 4017 as above, is by connecting the carry output of 4017 units level as the input clock for the 4017 of tens level. And if there is 4017 of hundreds level, then the carry output of 4017 of tens level is used as the input clock for the 4017 of hundreds level. And so on. While the reset input of all of 4017 are combined into one. Thus, the overall control system only requires two lines for columns control, ie the input clock (clock input for 4017 of unit level) and the reset input (composite of all reset of 4017). Thus, the preparation of the LED matrix is exactly the same as the MXLED simulation.

Power Current Calculation

From the explanations above, we can see that there are three kinds of transistors viewed from the position. First is the row controller transistor, second is the column (unit) controller transistor, third is the column block (tens) controller transistor. Of course this calculation assuming that the number of columns are not more than 100 columns.

Calculation of the row controller transistor current

If each LED using a current of I, then the total maximum amount of current through the line control transistor is I x number of columns. For example, if each of our LEDs designed to use 5mA current and the number of columns are 30 columns, then the row controller transistor should be able to drain 5 x 30 = 150mA current.

The next question is, what is the value of collector resistor of the transistor?

To answer these questions, we should see the path of current from the power supply to get to the ground. First, the power supply current enter the PNP transistor through the emitter to the collector. Then passes through the collector resistor, then continues to enter into LED, enter into the collector of column controller, then enter the collector of the block columns controller.

If the power supply used is 5V, how much is the clamp voltage across the resistor? The voltage across the resistor is 5V – V on LED – VCE line controller tansistor – VCE of column controller transistor – VCE of column block controllers transistor. LED clamp voltage is typically about 1.7 V, but there are some types of LEDs which have a clamp voltage of up to 3V. While VCE transistors in saturation state is typically around 0.3 V. We assume that we use a regular LED with a clamp voltage of 1.7 V. Thus, the voltage across the resistor pin is 5 – 1.7 – (3 x 0.3) = 2.4 V.

Once we know the clamp voltage at the collector resistor of the line controller transistor, to calculate the magnitude of the resistor is R = V / I = 2.4 V / 150mA = 16 ohms. Too bad that we might be difficult to obtain this value of 16 ohms. So we can use a slightly lower value, eg 15 ohms, so that the LED current will be slightly higher, or use a little higher, for example 18 ohms, so that the LED current will be slightly lower.

Things should be kept on the LED matrix design like this is, that these calculations is the calculation of the current if the scanning is running. If scanning is not running, then a current of 150mA will be entered on one LED alone And currents of this magnitude would likely destroy the LED. So, we must take precautions so that the current should only flow if scanning process has been running. A little good news is, if we use the MCS-51 as a controller, so when the reset (the scanning process is not running) port is always in a state of high. So, if the base of line controller transistor is connected to the MCS-51 port, so it can be sure that the current will not flow to the LEDs on the reset state. However, you must ensure that the program will not hang. Because if the program hangs and stops the scanning process, then it means disaster for your LED matrix. And if you are not sure that your program can run smoothly, then you can reduce the LED current so that even if the scanning process is not running, current flows are still small enough to be able to be borne by one LED.

To calculate the base resistor value of the line controller transistor, we only consider the transistor to work as a transistor switch, which is so current that flows is the saturation current. With the calculation of the collector current of 150mA, then we can use the C9012 transistor that has a current gain of about 150. We can take a value of 100 to make it more secure. With the gain of 100 and the collector current of 150mA, then the base current should be about 1.5 mA. Clamp voltage at the base resistor is approximately 5V – VBE, where VBE is about 0.7 V. Thus, the clamp voltage at the base resistor is about 4.3 V. Thus, the base resistor value is 4.3 V / 1.5 mA = 2K8. And again that this value is not available values. So we could slightly reduce the value to the nearest number of available, namely 2k7.

Calculation of the column controller transistor current

Column controller will sink as much current number of rows in that column. And we have determined that the number is eight lines. If we have determined that the LED current is 5mA, then the maximum current to be sunk by the column controller transistor is 8 x 5mA, which is 40mA. With the value of this, we simply use the C9013 transistor to control the column. The Gain of C9013 transistor is also about 150. And as before, we take saver value to 100 only. With the gain of 100 and the collector current of 40mA, then the base current in the column controller transistor is 0.4 mA.

Clamp voltage at the base resistor of the column controller transistor is the output voltage of 4017 minus 2x the VBE voltage. If we use a 5V power supply, then the output voltage of 4017 is approximately 4.8 V. Thus, the clamp voltage at the base resitor is about 4.8 – 2 x 0.7 = 3.4 V. Thus, the base resistor value of the column controller transistor is 3.4 V / 0.4 mA = 8K5. And again, this value is not available values. So, just use the 8K2.

Calculation of the block columns controller transistor current

The block columns controller transistor will sink as much current in the column controller transistor x 10, which is 10 x 40mA = 400mA. From the datasheet, C9013 has a maximum collector current of 500mA. So, we can still use the C9013 to controll block columns.

Clamp voltage at the base resistor of the block columns controller transistor is the voltage used to control this transistor reduced by 1x VBE. If we also use 4017 to control the block column, then the clamp voltage across the base resistor of the block columns controller transistor is approximately 4.8 – 0.7 = 4.1 V. Thus, the value of the base resistor of the block columns controller transistor is 4.1 V / 4mA = 1K.

That’s it. Happy trying

In the example in Showing images on LED matrix using simulator, the note is displayed as an image. First we create a text image, then we create a constant from the text image. After that it displayed as an image.

Displaying text in this way is only appropriate if the text to be displayed is short. In addition, the displayed text will not be changed anymore. If the note to be displayed is a long text, or text that is displayed will be changed, then there is a better way than that way.

A better way is as follows: First, we create a character constant. In the example here, we make a character constant of 8 rows x 5 columns character size. The character constant was created using Karakter.bmp that you can edit to fit your desires.

Once we get a constant character, by compile the Karakter.bmp using ImgTable.exe, then every time we will display the text, we do it by reading the text character-by-character. Each character is read, then displayed by looking at the character table. In this way, we can display any article and can be changed while the program is running. Of course you have to create a procedure to change the text to be displayed if you want to replace it.

Unfortunately the program listing only writen in assembly language. So, if you prefer to use the C language, please do the conversion yourself

If you want to try the example program using MXLED, do the simulator settings as in Showing images on LED matrix using simulator

Good luck

Controlling the LED matrix is actually almost the same as controlling seven segment. The difference is that the LEDs of seven segment are organized into seven sections which could form the figures. While the LED matrix, LEDs are arranged into a matrix that can be referenced by column and row. The columns on the LED matrix can be equated with the digits on the seven segment. While the lines on the LED matrix can be equated with LED a through LED g plus a decimal point LED on seven segment. Thus between the seven segment and LED matrix is basically the same, especially if the number of rows are only eight.

Then how to display images on the LED matrix? Yes basically the same as displaying the numbers on the seven segment. If you are already familiar with how to display data on the seven segment display using the buffer as is done in discussion about seven segment in the Easy and Fun Learning Microcontroller book, in which to display data on the seven segment, all we have to do is fill the display buffers, then to display image on the LED matrix, all we need to do is also just fill data on corresponding display buffers.

In the picture above, the size of the LED matrix that we use is 8 rows x 32 columns. This size is equivalent to seven segment which the number of digits are 32 digits. Thus basically we need a total of 32 bytes of display buffers. The LEDs on the top line we associate with bit 0 of port and successively LEDs on the lines below to bit 1, bit 2, and so on until bit 7. To make a LED lit on a particular line, then we need only fill the correlated bits with 0 or 1 depending on the configuration of the matrix that we use, active low or active high. For ease of understanding, we usually use active high so to lit the LED on the top line then we have to make the bit 0 to has the value of 1.

As an example, consider the logo below. The logo size is 32 x 32. Therefore, the logo may not be displayed on the LED matrix with the size of 32 x 8 at once. To display it, we have to split the logo into four parts. After that we have to show four parts one by one.

To the left of the logo there is a number from 0 to 7 and repeated up to four times. While above the logo are the numbers from 0 to 31. These figures will show us how to display the parts of the logo on the LED matrix. The figure above the logo shows the buffer index, while the figure at left of the logo shows the bit position. Thus, to show the first part of the logo (the top), then the buffer [0] must be filled with data 11111111b, buffer [1] = 00000001b, buffer [10] = 00011001b, and so on.

  0.        1.        2.        3.
  01234567890123456789012345678901
0 ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©
1 © .............................©
2 ©..........©©©©..©©©©..........©
3 ©........©©©©©©..©©©©©©........©
4 ©......©©©©©©©©..©©©©©©©©......©
5 ©.....©©©©...©©..©©...©©©©.....©
6 ©....©©©.....©©..©©.....©©©....©
7 ©...©©©......©©..©©......©©©...©
0 ©..©©©.......©©..©©.......©©©..©
1 ©..©©........©©..©©........©©..©
2 ©.©©©............©©............©
3 ©.©©.............©©............©
4 ©.©©©©©©©©©©©©©..©©©©©©©©©©©©©.©
5 ©.©©©©©©©©©©©©©..©©©©©©©©©©©©©.©
6 ©............©©.............©©.©
7 ©............©©............©©©.©
0 ©..©©........©©..©©........©©..©
1 ©..©©©.......©©..©©.......©©©..©
2 ©...©©©......©©..©©......©©©...©
3 ©....©©©.....©©..©©.....©©©....©
4 ©.....©©©©...©©..©©...©©©©.....©
5 ©......©©©©©©©©..©©©©©©©©......©
6 ©........©©©©©©..©©©©©©........©
7 ©..........©©©©..©©©©..........©
0 ©..............................©
1 ©..©©©.©..©..©©..©...©.©..©©©©.©
2 ©.©....©..©.©..©.©©..©.©.©.....©
3 ©.©....©©©©.©©©©.©.©.©....©©©..©
4 ©.©....©..©.©..©.©..©©.......©.©
5 ©..©©©.©..©.©..©.©...©...©©©©..©
6 ©..............................©
7 ©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©
The Logo.

To be able to fill these data to the buffer with ease, then we can create an image data table. This technique is similar to how to show the variation of Running LED on exercise 5 of the Easy and Fun Learning Microcontroller book or on the LED Simulation article. Each image table has the same size with the size of the buffer. And for the case of the logo above, we need four 32 bytes size image tables.

Like on the Running LED exercise, the work of preparing the table is a tedious job and requires precision. But you should not be discouraged if you want to make the table of the large and complicated image because you can use the aid program ImgTable.exe. The program will help you to convert bmp format images into an image table that we can use it in the program using either the M51 format or using the SDCC format. So to get an image table, you simply create an image using MSPaint, and then do the conversion using ImgTable.exe.

ImgTable.exe can do the conversion from bmp file with a monochrome format up to 24 bits format. But because the table will be used to lit the LED which of course is equivalent to a monochrome format, the 24 bits format would be first converted by ImgTable.exe into the monochrome format. Therefore, it is better if you save the images you create with monochrome format to save on file size.

Rules applied by ImgTable is that the pixels that are black will be converted into 1, while the white pixels into 0. For colors other than black and white, then the three basic color elements will be summed first, then divided by three. After that, if the value is closer to the black will be interpreted as black, and if it is closer to white will be interpreted as white.

Table creation sequence is from left to right and from top to bottom. From top to bottom means every eight pixels will be taken as one byte. For example, an image with a size of 32 x 32, it will be four tables with the size of 32 bytes. The first table stores the data of the coordinates (0,0) to (31,7) by the rule that the upper left pixel is (0,0) and the lower right pixel is (31.31). The second table is (0,8) to (31,15). So forth.

In this example, all tables store the entire image data appropriately because the high of the image size is a multiples of eight. If the size of the image is not a multiples of eight, then the final table will have the remaining bits. For example if the image size is 32 (width) x 33 (height), then the number of tables are five tables with size of 32 bytes. And the last table only use bit 0. While bit 1 to bit 7 will be filled with 0.

Return to the LED matrix, we must display the four parts of the logo one by one. But if we display them alternately, then the shape of the logo will not be seen clearly. We will only see the incomplete images that appear alternately. Therefore we have to show by shifting it up or down. However, we have created tables that contains the data of the image blocks. So we can not retrieve data from the image coordinates (0,1) to (31,8) directly. For that, we need one more buffer with the same size as the first buffer. If we call the first buffer as the display buffer, then we call the second buffer as hidden buffer because it was not for displaying data to the LED matrix. This buffer is only used as an aid in manipulating the display data.

In case we want to shift the image up, then we can describe the arrangement as if the buffer is as follows:

01245...
abcde...
Numbers = the display buffer, alfabets = hidden buffer.

The first time, we fill the display buffer with data 0, so that all the LEDs will be turned off. Then we put the first image block table on hidden buffer. After that do a bit shifting between a and 0, b and 1, c and 2, and so on. Do these shifts of up to eight times, which means that all parts of the image block has been on display buffer. And before doing the ninth shift, we must place the second image block into the hidden buffer. And the next step is an iteration of the previous step.

For more details, you can see the program listing for the demo above that is written in the format of M51 and c. In the listing, there is DelayTime constants that you can replace to change the speed of picture motions.

To try on the simulator, then you must set the port link so that both Port0 and Port1 are linked to MXLED.exe by the message link with the WM_USER message, and lParam of Port0 is 2 and lParam of Port1 is 1. You also have to set the configuration of MXLED size as 8 x 32 landscape.

Happy trying and please do not hesitate to ask if there are less clear. Hopefully useful.

Actually, he asked me to place the digits control using P0, and P2 for segment data. However, because previously I had made the program with P0 as the control of digits and P1 for segment data, so that I don’t need to reconfigure when I tried on the simulator, I keep using P0 as the control of digits and P1 for segment data. Therefore if you have already used P0 as the control of digits and P1 for segment data, then you need to change the PortDigit and PortData constants at the top of the program.

To realize the friend request, I use the way I usually do if I want to display data on the seven segment, i.e. put seven segment manager procedure on the timer interrupt. This ensures our programs to be able to display data on the seven segment with good brightness. There are several examples of programs that put the seven segment scanning process in the main program. But we know that the seven segment which installed in a multiplex must continuously scanned to be able to display the data. If the program are less keen in doing the scanning, then the display will be disturbed. Probably will not light up, and this is the worst, or at least the light intensity of the seven segment will be dimmed. And it is very unpleasant. By using a timer interrupt to do the scanning, we can relieve our attention from the scanning process, because it has been fully handled the interrupt handler. So this way is the best way (at least I think so, you may leave a comment if you do not agree).

Then, because the program is indeed a very simple program, then we can use all facilities owned by the microcontroller without much consideration. For easier handling in counter addition or subtraction, we can use the external interrupts, i.e. ext0 and ext1. So we just attach the button at P3.2 (ext0) and P3.3 (ext1). Of course we must use the button that really bounce-free (bounceless), so that if we press the button once, then we also get only one count. To raise the count, we use ext0. As for lowering the count, we use ext1. In the main program, we do not even do anything.

Using interrupts to handle button is very simple in terms of response. But the drawback is that the button used should be a bounceless type. In addition, only P3.2 and P3.3 can be used. Therefore, using debouncing technique as I have discussed in the Easy and Fun Learning Microcontroller book will probably be a better solution in handling button. For that, I also will feature a program that handles the button not on the external interrupt, but placed on the timer interrupt. Thus, in addition to the timer interrupt is used to perform seven segment scanning is also used for button scanning.

In scanning through the timer interrupt, we can use any button, does not have to use the bounceless. We just need to adjust how quickly button bounce will be addressed. To try it, you can change the value MaxWait to 255 to slow down the response of the button bounce. If you use a simulator, and a computer that used is quite a fast computer, it may be the key response is still too fast. You simply change the TimeOutDown and TimeOutUp type to be unsigned int, and change the MaxWait value to higher rates. After that, try to press the button on Tombol.exe with high frequency. You will find that if the button is pressed too quickly, then presses the button too fast will be considered as a bounce. Thus, we can use the buttons that are not really bounce free. All you need to do is adjusting how sensitive your buttons, i.e. by setting the MaxWait value. And generally, you will not use numbers higher than 255. Therefore, the data type I use is unsigned char.

Remember, if you use Tombol.exe as simulated buttons, then you must set the used port (in this case is P3) on the simulator to be linked in Link Message. This is necessary because Tombol.exe send the keystrokes signals to the simulator through Window Message. As for the program that handles button via the external interrupts, then you can not use Tombol.exe, because Tombol.exe could not provide an interrupt signal to the simulator. You must use the existing buttons on the simulator. To display this button port window is from the View-Port menu. Then from the window, double-click on the desired port, which is the name of the port, not on its value, because if you double-click on the value, then it will appear the dialog to change the value of the port or the relevant registers.

Another friend asked me, “How do I create a program that constantly monitor keystrokes, but other operations continue to run without being interrupted by the oversight of the key”. Well, two examples of the above program, whether using an external interrupt and those that use the button scanning on the timer interrupt, has conducted monitoring of key presses continuously, while at the main program does not even do anything. Thus, the above example is also an answer to this question. You simply put the other operations in the main program, while the supervision of the button has been continuously monitored.

I wrote the program in c and M51 language only. So if you just have a Micro v5.4, which is the IDE that I include in the Easy and Fun Learning Microcontroller book, then you should first download the latest version of the IDE that supports the C language.

Happy trying, hopefully useful.

Source

Seven Segment is one of the most common components used primarily to display data in the form of numbers. For that, Microcontroller Project also provides a simulation for seven segment, namely SSLED.exe.

Seven segment simulation provided by the SSLED.exe has eight-digit in multiplex manner. Multiplex technique is the most commonly used because of its compact wiring and requires only a few ports to control it. How to control the seven segment arranged in multiplex is by dividing two kinds of line, i.e. the data line and digits control line. Data line is used to determine which LED are lit, while the digits controller line is used to set which digits are lit.

Data line and digits control line of SSLED.exe received using window message as WM_USER. If lParam is 1, then the received signal will be considered as a signal for digits control line. Whereas if the lParam value is 2, then the received signal will be considered as a signal for the data line.

On the data line, bit 0 will be used for LED a, bit 1 to turn on the LED b, and so on until bit 6 to turn on the LED g. While the bit 7 is used to lit the decimal point LED. If a bit is 1, then the corresponding LED will lit. This would fit with the common cathode type. However, we can also reverse the data so that if the data sent value is FF, then the data would be considered 00. This capability is useful for adjustment with seven segment types to be used.

SSLED.exe provides two ways of controlling the digits, i.e. the parallel way and the counter way. In the parallel way, each digit can be individually activated depending on the bit of the line controller. Bit 0 in the line controller will control the rightmost digit and bit 7 will control the leftmost digit. If a bit is 1, then the corresponding digits will be active. And just as in the data line, the line controller digits can also be reversed.

In counter mode, only bit 0 and bit 1 in the line controller digit is used. Bit 0 is used to reset the counter, so the active digit will be the rightmost digit. While the bit 1 is used to shift the active digit to be the next left digit, or name it as raising the counter count. There are two kinds of how to raise the counter count, i.e. L to H transition or H to L transition. If we use the L to H transition, then the counter will be increased if bit 1 state changed from 0 to 1. Conversely, if the transition used are H to L, then counter would be raised if the bit condition changed from 1 to 0.

If the current digit is the leftmost digit and count raised, the active digit will return to the rightmost digit.

The picture above is an example of how simulation if operated for seven segment display digital clock program. Above program is actually a modification of the program on Interrupts chapter of the Easy and Fun Learning Microcontroller book, ie on Timer.A51 program. But in the book we will try to program the actual seven segment, so we need to save money just by using four digits only. While in this simulation, we have simulated seven segment that provides eight digits. Therefore, we can show not only hours and minutes but also seconds. In fact we still have the remaining two digits. The remaining digits are used to separate hours to minutes and minutes to seconds, i.e. by displaying a (-) sign. Therefore, we need a little modification of the Timer.A51 program in order to display the seconds and the separation mark.

The source code is written with the format of M51 and c where the data signal transmitted using P0, and the digit control signal using P1. Thus, we must set P0 to link by the Link Message with a WM_USER message, and lParam value is 2 and fill the Handle with the Handle of running SSLED.exe using Capture Handle button. Do this to P1 too. But in P1, lParam value is 1. And remember, remove the check mark on the Update Display menu on the simulator.

But keep in mind that the program is written to run on a microcontroller with a 11.592 MHz crystal. So the second change speed during the simulation may be is not correct. And its speed depends on the speed of the computer you use.

Well, interesting isn’t it? Happy trying

Source

Early game which is always done by people who are just learning the microcontroller is lit the LED. Although the first time we usually just turn on the LEDs moving to the right or left only, and usually things like that would be boring, but it is very important to understand how to program the microcontroller. Besides, if we want to develop programs that not only lit the LED which is lit only shifted to the right or left, then this game could get very interesting.

For example, the LED experiment using the table ie LED5.A51 in the Easy and Fun Learning microcontroller book, is a very interesting LED game. The picture above shows how the LED game if run on the simulator which is connected to VLED.

All you need to do to use VLED.exe when running simulations for LED5.A51 is connecting the P1 by Link Message with Message to be sent = WM_USER (1024), then fill Handle by Capture Handle to the running VLED.

Link setting is done by clicking the Option-Port menu of the simulator window. After that, the Port Settings window will appear. In this window, there are four tabs, the tab for Port 0 to Port 3. The contents of each tab are the same, that govern how the ports are connected. If you do not want to connect the ports anywhere, then choose None Link. Then Link Port is chosen if simulation port will be linked with the physical ports, such as parallel port or installed PPI port. Meanwhile, Link Message is used if the simulator is connected to another program via the Window Message. And the last is the Link File, that is if the port will be connected to a file.

If the Link Message selected, you must specify the Message to be sent, lParam to be sent, also Handle of the Window of the program receives the message. This parameter depends on the program that you want to link. For example, VLED received a WM_USER message, i.e. 1024. So the Message to be sent will also have to be 1024. While the lParam is not taken into account by VLED, so let it be what it is. And that should not be forgotten is to fill the Window Handle of the linked program.

To fill this Handle value can be done by clicking on the Capture Handle button, then click on the program that you want to link. Remember! After you click on the Capture Handle button should not click on anything other than the program that you want to link. Because the Capture Handle will fetch the handle of any clicked after this button is clicked. If the handle filling was done, then the Caption will usually appear the words as in the linked program. For example if the linked is VLED, then it would appear the words “Virtual LED”. After that, close the Port Setting window and enjoy the simulation.

You can also see how the LEDs run on the real LED by linking Port1 using the Link Port, then fill out the Address to 378, i.e. the address for the port. And you must install the LEDs on the parallel port as shown here:

Installation of the LED display on the parallel port.

To try the program, you can download the source code written either using assembly language and c language. And remember! You should discard the checkmark on the Option-Update Display menu in the simulator to make the simulator run faster. LED running speed may be not the same between your computer with the animation above. The speed of simulation depends on the speed of your computer.

Happy trying.

Source