Data Compression 237

The purpose of the above discussion is to demonstrate that the programmer must exercise much more care in the details of program design for a microcontroller than is necessary for a larger machine. The above sorting routine would be of no concern for a typical desktop machine because RAM is usually of no consideration with such machines. It might not be a problem for some microcontroller applications, but in a case where RAM is limited and needed, it might make the difference between being able to get the program to run or not.

In most instances, the elegance of recursive code has a cost of RAM. Usually a recursive program will be slower than the equivalent linear program. The microcontroller programmer must examine each instance of code to determine if the elegant recursive program has hidden side effects that end up costing more in computer resources than is gained in small code size.

EXERCISES

1.Write a program to run on a host computer that will test the time required to execute both a quick sort and a Shell sort on random large arrays. Make the array sizes selectable from the keyboard.

2.Test both the quick sort and Shell sort for various array sizes. Ex­ amine the time required to execute the sorts for several random arrays. Explain what is happening when arrays of 4090, 4095, and 4096 entries are sorted.

Data Compression

Another program problem that can arise with microcontroller applications is handling displays in which there are many phrases and names each consisting of several letters. The question that must be considered is the most efficient method of storing these phrases and names, in memory so that they can be recalled for display. The oldest, and yet very effective, method of compressing the data for storage is to use a Huffman code. This code is developed based on the statistical occurrence of each letter in the alphabet. A letter that occurs frequently will be given a short code sequence. A letter that is seen infrequently can be assigned a long code, which will not appreciably affect the number of bits per letter in the message.

238 Chapter 5 Programming Large 8-Bit Systems

Huffman codes are self-synchronizing. A long string of characters can be represented as a series of bits, and the decoding program can find each character in the sequence without any special flags to designate the end of each character. Messages stored as ASCII characters require at least 7 bits per character, and because of the nature of storage in a computer, 8 bits are usually assigned to each character. With a Huffman code, it is possible to reduce the average number of bits per character for the whole English language to about 4.5 bits per character. Sometimes even fewer bits are needed with limited messages.

The programmer does all of the Huffman encoding and the computer must decode the messages for display. Huffman decoding requires extensive bit manipulation, so C is an ideal language to decode the messages.

A Huffman decoding scheme can be represented by a strictly binary tree. A binary tree is comprised of a collection of nodes. Each node has two descendents, often called the right and left descendents (thus the term binary tree). The terminating node in a tree is called a leaf. In a strictly binary tree, every nonleaf node has both a right and left descendent. If a strictly binary tree has n leafs, it has a total of 2n – 1 nodes.

The Huffman code is decoded in this manner. The sequence always starts at the root node. The code sequence to be decoded is examined a bit at a time. If the bit is a 0, move to the left node. If the bit is a 1, move to the right node. The tree is traversed until a leaf is found which contains the desired character. The sequence is then restarted at the root node. If the tree is not known, the sequence of bits is bewildering. Usually it is found that the occurrence of ones and zeros is about equally likely, so no statistical analysis can be applied to decode the sequence easily. A disadvantage is that if a single bit in the sequence is lost, the remainder of the code stream is undecipherable. Of course, the advantage to the Huffman code is that it takes somewhere between one-quarter and one-half the number of bits to represent a message as is required by the ASCII code. A Huffman Code tree is shown in Figure 5-1. The bit sequence 111111100101111010100000 as decoded by this tree is seen to spell the word “committee.” This sequence requires 23 bits, and the ASCII code needed to represent committee is 72 bits long. Of course, this tree was designed specifically for the word “committee,” but try to encode other words that can be made of these same letters such as “tic,” “me,” “come,” “tom,” “mite,” etc., and you will find that every word that can be derived from this tree requires fewer bits than the corresponding ASCII sequence would need.

Data Compression 239

If you look at Figure 5-1, you will note that the letters e, m, and t require only 2 bits each to determine the value. These letters were selected to be represented by 2-bit values because they are the most frequently occurring letters in the message. The remainder of the letters require more bits but they do not occur so often in the message.

l

Figure 5-1: Huffman Code Tree

The code must be designed specifically for the messages to be represented. First, all of the characters in all of the messages are collected into a histogram of the occurrence of each character. Remember to include spaces and other such characters in the list. Once you have determined the number of different characters in the list, you can design a tree that will compress the code. If the list contains n different characters, there will be 2n – 1 nodes in the tree. Each level in the tree, starting from the root node at the zeroth level, can contain 2k nodes or leafs. This tree cannot be balanced like a binary sort tree because we want some of the leafs to be determined by as few as 2 bits, and we do not care about the number of bits needed to determine a character that occurs infrequently. In Figure 5-1, levels 0 and 1 contain only nodes with no leaves. Level 0 contains three leaves and one node. It is through this single node that all of the remainder of the characters must be found.

A series of avionics-related items were put together and an analysis of the frequency of characters in these messages was completed. A Huffman code that will encode these data effectively was created. This

242 Chapter 5 Programming Large 8-Bit Systems

{

if((mask & M[i])==0)

j++; /* use next node entry if bit is zero */ else

j+=Node[j];/*jump to designated node when one */

if(Node[j]<0)

{/* if a printable, send it out */ putchar(k=Node[l]&0x7f);

j=0; /* also go to the root node */

}

if((mask>>=1)==0) /* if the mask is zero,turn on MSB */

{

mask = 0x80;

i++; /* and get the next byte from message */

}

}

}

Listing 5-1: Huffman Decode Function

The next part of the program is the Huffman tree needed to decode the data. This tree was constructed to decode data specifically for the nine messages of this problem. You will note that each byte in the table is a node. Intermixed in the table are numbers that dictate jumps to the next node depending on whether the incoming bit is a zero or a one. The leaves each contain a negative number that is generated by the inclusive OR of the character to be printed and the number 0x80.

The messages are sent to the function decode as a pointer to a bit array. The data must be examined one bit at a time to implement the decoding. The bit selection is accomplished by ANDing the data in the incoming message with the contents of the variable mask. Mask is initially set to 0x80, so the most significant bit of the first byte of the incoming data is selected. Later in the routine, the value of mask will be shifted right to select other bits in the incoming sequence. The variable k is loaded with the character to be output during the program. The linefeed character ‘\n’ was used to determine the end of message, so the decoding sequence will be executed until the

Data Compression 243

character that was output from the program is a ‘\n’. Recall the way that the tree was built. If an incoming bit is 0, the next node in the tree will be taken. If the incoming bit is 1, the content of the current node will be added to the node pointer to determine the next node in the tree. If at any time a negative number is found in the tree, a leaf has been found. The data portion of this byte, bits 0 through 6, will be sent out to the screen.

After each bit is processed, the next bit in the sequence must be processed. The next bit is selected by shifting the mask byte to the right one bit. If the result of this shift creates a zero mask, a new mask with a value of 0x80 is created and the next byte from the incoming message code is selected when i is incremented.

The simple program below causes the nine messages to be printed on the screen:

main()

{

decode(M1);

decode(M2);

decode(M3);

decode(M4);

decode(M5);

decode(M6);

decode(M7);

decode(M8);

decode(M9);

}

Listing 5-2: Message Printing Program

The result of execution of this program is shown below. The nine messages contain 124 characters that would require 992 bits of memory to store the messages in standard ASCII format. The encoded sequence requires 500 bits or 63 bytes of storage.

ALTITUDE

HEADING

DISTANCE REMAINING

FUEL REMAINING

AIR SPEED

244 Chapter 5 Programming Large 8-Bit Systems

IN HOURS

TIME

ESTIMATED TIME OF ARRIVAL

GROUND SPEED

The function below was written to show the difference in memory required for the Huffman code and conventional ASCII coding. This program was compiled as a function to be run on the MC68HC11. The function decode given in Listing 5-1 was compiled to MC68HC11 code. The result of these two compilations showed that Listing 5-1 created an object module that was 255 bytes long, and Listing 5-2 created an object module that was 277 bytes long. The Huffman code for even the small message list in this case provided nearly 10% reduction in code size. A larger message list would provide an even greater memory savings because the code required to decode the messages would be allocated over more message characters to be sent out.

#include <stdio.h> char M1[]=”ALTITUDE”; char M2[]=”HEADING”;

char M3[]=”DISTANCE REMAINING”; char M4[]=”FUEL REMAINING”; char M5[]=”AIR SPEED”;

char M6[]=”IN HOURS”; char M7[]=”TIME”;

char M8[]=”ESTIMATED TIME OF ARRIVAL”; char M9[]=”GROUND SPEED”;

void decode(char *M)

{

while(*M !=0) putchar(*M++);

putchar(‘\n’);

}

Listing 5-3: Nonencoded Output Function

EXERCISES

1.How could the tree in Listing 5-1 be altered to reduce its size by 8 bytes? What effect would this change have on the routine decode? Would there be a net savings in overall code?