The Microcontroller Idea Book (Jan Axelson, 1994)

Calling Assembly-language Routines

2048h in code memory. This is because BASIC-52 checks these locations on bootup to determine what additions have been made to BASIC-52. If you by chance have certain data stored at these locations, BASIC-52 will look for the additions it thinks you have, and crash when it doesn’t find them.

If you have an EPROM addressed at 8000h, and you don’t need the entire EPROM for BASIC-52 programs, you can store your assembly-language routines in the unused area. BASIC-52’s (F)PROG command stores programs in sequence beginning at 8010h, so to leave the most room for BASIC programs, you should place your assembly-language routines in the EPROM’s highest addresses.

You can also add NVRAM or EPROM in any unused area of combined code/data memory. For example, you could add an 8K NVRAM addressed from 2000h to 3FFFh, or a 16K EPROM from 4000h to 7FFFh.

Software for Uploading

You’ll also need a way to load your routines from your personal computer into your 8052-BASIC system’s memory. All that’s required here are your host computer’s communications software and a BASIC-52 program that reads and stores the uploaded file.

Appendix B contains two such programs. Listing B-1, HEX2RAM.BAS, loads Intel Hex files from your personal computer into RAM, including NVRAM, in a BASIC-52 system. Listing B-2, HEXLOAD.BAS, does the same, and also offers the options of loading into EPROM or EEPROM.

On your host computer, you can the same communications software that you use to upload BASIC-52 programs, as described in Chapter 3.

Another option for loading routines from your host computer into memory is to program an EPROM or other device with a device programmer, and then insert the programmed device into your BASIC-52 system. If you use this method, you can access the chip as code-only memory, rather than combined code/data memory, since you don’t need to write to it when it’s installed in the 8052-BASIC system.

Loading a Routine

When you have the necessary tools, you’re ready to write an assembly-language routine and assemble, upload, and call, or run, it. As a first try, we’ll begin with a very simple routine, just to verify that the circuits and techniques are working.

Listing 13-1 has just one function: it toggles pin 1 (Port 1, bit 0) of the 8052. An ORG directive tells the assembler the address at which to begin loading the routine. Listing 13-1

Chapter 13

Listing 13-1. Source file for a simple program to test assembly-language interfacing with BASIC-52.

end

specifies 3000h. You can change the address to match whatever locations you have available in your system.

The program body’s single instruction complements bit 0 of Port 1, changing it from high to low or low to high. A ret instruction then returns control to BASIC-52.

To create and test the routine, do the following:

Use a text editor to create a file containing Listing 13-1.

Use your assembler to assemble the file. A typical command line looks like this:

A51 bittog.asm -L bittog.lst -O bittog.hex

The above command tells the assembler to create two files: the listing file bittog.lst (shown in Listing 13-2) and the object file bittog.hex, in Intel hex format (shown in Listing 13-3).

File Formats for Assembly-language Routines

This is a good time to look at Intel Hex and other file formats in greater detail. Most EPROM programmers are able to program EPROMs directly from the files created by assemblers and compilers, but the file must be in a format that the programmer recognizes. Three

Calling Assembly-language Routines

Figure 13-1. Examples of a byte expressed in binary, hexadecimal, and the ASCII codes representing the Hex characters.

common formats are binary, ASCII Hex, and Intel Hex. Intel Hex is also the format required for programs that you upload using Listings B-1 and B-2. Figure 13-1 shows a byte expressed in binary, hexadecimal, and ASCII hex.

Binary

A binary file is the most primitive or unadorned type. It consists of a sequence of bytes that exactly corresponds to the bytes to be programmed. The file contains no addressing information for loading or programming, and no error-checking.

To view or edit a binary file on a personal computer, you need a special file-viewing utility. This is because conventional file-viewing techniques, such as MS-DOS’s TYPE command, will interpret the bytes as ASCII codes and will display the ASCII characters that the codes represent. For example, the value “1" in a binary file appears on-screen as a happy-face character.

ASCII Hex

In ASCII Hex, or pure Hex, format, each byte is expressed as a 2-character hexadecimal number, with each character represented by its ASCII code. ASCII Hex files contain only these 16 codes: 30h through 39h (for numerals 0 through 9) and 41h through 46h (for capital letters A through F).

You can easily view and edit ASCII Hex files on a personal computer, because the computer displays the ASCII characters that the codes represent. However, the EPROM programmer or uploading program must translate the codes into binary data before it writes the codes into the device to be programmed.

Because each byte to be programmed requires two codes, an ASCII Hex file is twice as long as the resulting file that is programmed into the EPROM.

Listing 13-3. Intel Hex file created by assembling the source file in Listing 13-1.

:03300000B2902269

:00000001FF

Chapter 13

Intel Hex

Like ASCII Hex, Intel Hex format stores bytes as ASCII codes representing hexadecimal characters. But Intel Hex adds addressing and error-checking information for more flexible programming and more reliable file transfer.

Each Intel Hex file consists of a series of records. Table 13-1 has more details about the records and what they contain. You don’t have to understand everything about Intel Hex format in order to use it, but the information can be useful if you run into problems and want to examine the contents of a file.

Assembling a Program

When you assemble a program, the message Assembly Successful, or something similar, means that the assembler found no errors that prevented it from creating the object file. If you do see error messages, you’ll have to find out what’s wrong before continuing. The listing file also includes the error messages, and these should help you track down any problems.

Calling Assembly-language Routines

Successful assembly is a good sign, but it doesn’t mean that the program is error-free. As in any programming language, a line of code may contain instructions that are valid, but that do not do what you intended. It’s a good idea to at least scan the listing created by the assembler before you try to run a routine, to look for obvious errors.

Different assemblers may have slightly different syntax rules. For example, some require org and end to have a leading period (.org, .end). Check your assembler’s documentation for the specifics.

Uploading a Program

When you’re ready to load the program into RAM, boot your 8052-BASIC system, connect the serial link to your personal computer, and run your communications software. Use the software to upload Listing B-1 or B-2, in the same way that you upload any BASIC-52 program from disk.

For loading Intel hex files, you can set up your host computer’s software so that it waits to receive the BASIC-52 “>” prompt (ASCII code 62) after each uploaded line. This will ensure that BASIC-52 has enough time to process each line before the next one arrives. Use this method only with Intel Hex files, not BASIC-52 programs. If a BASIC-52 program contains any “>” (greater than) operators, the software will think that these indicate the end of a program line. Intel Hex files contain no “>” characters, so there is no problem.

If you want to wait for the “>” character, in Procomm Plus, from the Setup menu, select Terminal Options, then Protocol Options, ASCII Options, and set the pace character to 62. Character pacing and line pacing can be 0. In the Windows terminal, select Settings, then Text Transfers, One Line at a Time, and enter “>” under Wait for Prompt String. Other software should have similar abilities.

If you wish, you can use BASIC-52’s (F)PROG command to store the program in NV memory so it’s available without having to upload each time.

To use Listing B-1 or B-2, run the program and, at the prompt, use your communications software to upload your object file. The file will load into the locations specified by your source file. The program will display error messages if it has problems with the uploading. For proper calculation of the programming-pulse width in Listing B-2, set BASIC-52’s XTAL operator to match your crystal’s frequency.

If the file loads successfully, you’re ready to test it. Connect a logic probe to pin 1 on the 8052, or set a voltmeter to measure the voltage from pin 1 to pin 20 (ground) on the chip. To call your subroutine, enter and run this BASIC-52 program:

Calling Assembly-language Routines

statement must match the address in your file’s org directive. A missing ret instruction in the routine will also cause the system to crash.

Example: Creating a Sine Wave

When you have the simple routine working, you’re ready to move on to bigger things. For the sine-wave project, we’ll begin by generating a sine wave entirely with BASIC-52 statements. This way, we can first test the added circuits as well as the algorithm, or sequence of steps, that we plan to use to generate the sine wave. It also illustrates the speed limits of BASIC-52.

The Circuits

Figure 13-2 shows the circuit that interfaces to the 8052. I adapted the circuit from an example in National Semiconductor’s data sheet for the DAC0832.

U1 is a DAC0832 digital-to-analog converter, or DAC, which converts data inputs D0-D7 into an analog voltage. D0-D7 are controlled by an output port at E400h. You may change this address to match any output port on your system.

Listing 13-4. Sine-wave generator for Figure 13-2’s circuit.

10 REM Begins by calculating and storing sine values

20 REM for 256 locations along a sine wave.

30 REM Line 100 converts a position in the sine wave 40 REM (0-255) to the radians required by the sine

50 REM operator: (0.0246 = 2*PI/256). Adding 1 to the 60 REM sines makes all values positive, from 0 to +2. 70 REM Multiplying by 127.5 results in values that

80 REM range from 0 to 255.

90 FOR I=0 TO 255

100 XBY(3000H+I)=INT((SIN(I*.0246)+1)*127.5+.5)

110 NEXT I

120 PRINT “Sine values are stored in RAM (3000h-30FFh)” 130 PRINT “Press Control+C to quit”

140 REM Write the values in sequence to E400h

150 DO

160 FOR I=3000H TO 30FFH

170 XBY(0E400H)=XBY(I)

180 NEXT I

190 WHILE 1=1

200 END

Chapter 13

The DAC is configured in its flow-through and voltage-switching modes. In flow-through mode, the analog output continuously reflects the data inputs. The chip has several control signals for latching inputs and outputs, but these aren’t needed by our circuit.

In voltage-switching mode, the analog output is a voltage proportional to the value of the byte formed by D0-D7. An LM385 2.5-volt reference is applied across current output terminals IOUT1 and IOUT2, and the output appears at VREF. (This configuration is the inverse of the device’s current-switching mode, where VREF is an input and IOUT1 and IOUT2 are outputs, as their names suggest.)

Op amp U2A buffers the output, and U2B is a low-pass filter that helps to smooth VOUT.

A BASIC Program

Listing 13-4 causes a sine wave to appear at VOUT. The sine wave represents the value of the trigonometric sine function for an angle that varies continuously from 0 to 360 degrees, or 0 to 6.28 (2*PI) radians. Lines 90-110 are a loop that selects 256 equally-spaced points along one cycle of the sine wave, calculates the sine for each, and stores the values in RAM. The program uses BASIC-52’s SIN operator in calculating the values. Sine values normally vary from +1 to -1, but line 100 adjusts the values so that they vary from 0 to 255, which is the range of inputs accepted by the 8-bit DAC. Using these values, 0 is the negative peak, 255 is the positive peak, and the zero crossing occurs midway between points 127 and 128.

To generate the sine wave, Lines 150-180 are a loop that reads each value in sequence from RAM and writes it to an output port at E400h. After writing a complete cycle, the program loops back and begins another. The sine wave repeats endlessly, until the user presses

CONTROL+C.

Listing 13-4 creates a perfectly good sine wave, but at a very low frequency. Using 12-Megahertz crystal to clock the 8052, the frequency is only about 0.7 Hertz, or 1.5 seconds per cycle.

Adding Assembly Language

To speed things up, Listing 13-5 is an assembly-language routine that performs the functions of lines 150-180 in Listing 13-4. As in the original program, Listing 13-5 copies values in sequence from RAM to E400h, repeating the sequence after 256 writes. The routine illustrates a couple of major differences between BASIC and assembly-language programming.

One is that assembly language has no built-in FOR, DO, or WHILE loops. Instead, you have to create loop structures from the instructions available. Listing 13-5 creates a 256-step

Calling Assembly-language Routines

Listing 13-5. Assembly-language sine-wave routine for Figure 13-2’s circuit..

;Reads and copies values in sequence from locations 3000h ;to 30FFh to E400h. A DAC0832 generates a sine wave from ;the values.

;A keypress terminates the routine and returns to BASIC-52.

end

Chapter 13

FOR loop by loading FFh into register dpl (the lower byte of dptr), and decrementing dpl repeatedly until it equals zero.

In assembly language, you also do not have built-in conveniences like BASIC-52’s ability to terminate a program on CONTROL+C. You have to add these features yourself. In Listing 13-5, after each complete cycle of the sine wave, the program checks the serial port’s receive flag. If the flag is set, it means that the user has pressed a key, and the program returns to the BASIC-52 prompt. Otherwise, the program begins another cycle of the sine wave.

To run Listing 13-5, create a source file with your text editor, assemble it, and upload it to RAM as before. Edit Listing 13-4 by removing lines 150-180 and adding this line:

150 CALL 3100h

Now when you run Listing 13-4, you should again see a sine wave at VOUT, but at a much higher frequency.

With a 12-Megahertz crystal, the sine wave should be around 350 Hertz, or 2.8 milliseconds per cycle. You can verify this by consulting the 8052’s data book, which tells the number of machine cycles required to execute each instruction. At 12 Megahertz, each machine cycle is 1 microsecond, and one complete cycle requires 11 microseconds multiplied by 255 points on the wave, plus 6 microseconds to test the serial flag, or 2811 microseconds total.

With different crystal frequencies, the output frequency will vary in direct proportion. For example, with a 6-Megahertz crystal, the sine wave will be half as fast.

To slow down the sine wave, you can add “do-nothing” instructions to the code. For example adding a nop (no operation) instruction in the main loop will add 1 microsecond to the time between points on the wave, for a frequency of 326 Hertz. For long delays, you can insert a timing loop that executes after each point in the wave.

Listing 13-5 still relies on BASIC-52 to calculate the sine values and store them in RAM. Although you can also write these parts in assembly language, doing so in BASIC is much easier, and doesn’t affect the frequency of the sine wave that results. Even if you later decide to write this part in assembly language, with BASIC-52 you can test each section of the code as you go along.

When you have your assembly-language routine in the form you want it, you can use Listing B-2 or an EPROM programmer to store the code in EPROM. If your EPROM has different addressing than the RAM you used to test the code, you must change the ORG directive in the source file to match the new location, and reassemble the file before you program it into the EPROM.