Updates to this book are available at <http://www.hpcalc.org>.

F.H. Gilbert <andrell@iname.com>

Eric Rechlin <eric@hpcalc.org>

Part I: HP48 Programming Concepts *

1 Introduction to User RPL and System RPL *

2 Assembly language and machine language *

3 The binary base and nibbles *

4 Converting from binary to decimal *

5 Most significant bit and least significant bit *

6 Fractional numbers *

7 Calculating using base 2 *

8 Hexadecimal base *

9 Converting from hexadecimal to decimal *

10 Writing groups of four bits (nibbles) using hexadecimal *

11 Is all that number crunching needed? *

12 The BCD: "Binary Coded Decimal" *

13 Converting a decimal to its BCD form *

14 Usual BCD and "Extended BCD" *

15 Calculating using BCD *

16 Logical operations *

17 Review: Numerical bases *

18 Review: Calculations *

Part II: Programming Tools *

19 An assembler: HP-ASM *

20 HP-ASM Commands *

21 Assembling code with HP-ASM *

22 Additional HP-ASM features *

23 A fast text editor *

Part III: The Saturn Processor *

24 Saturn registers *

25 The fields of working registers *

26 The P register and WP *

27 Circular handling of numbers inside the processor *

28 RSTK *

29 Flags: ST, HST, and Carry *

30 OUT and IN *

31 How the processor works: life of an instruction *

32 What is a processor cycle? *

Part IV: Saturn Instruction Set *

33 Working register instructions *

34 Save registers *

35 Pointers *

36 Reading memory within a field *

37 Reading from memory with a value *

38 Writing to memory within a field *

39 Writing to memory with a value *

40 Jumping and tests *

41 Relative, absolute, and indirect jumps *

42 Calling a subroutine *

43 The tests *

44 Using register P *

45 The RSTK stack *

46 Registers IN and OUT *

47 Status Bits (ST) *

48 Hardware Status Bits (HST) *

49 Saturn DEC/HEX mode *

50 Interruptions *

51 Bus-related instructions *

Part V: HP48 Objects *

52 Simple Objects *

53 Compound Objects *

54 Primitive Code Object *

Part VI: Writing Programs *

55 Doing loops *

56 Reading from the keyboard *

57 Manipulating the stack *

58 Creating a program for creating macros *

59 Memory management *

60 Graphics *

1. 
   HP48 Programming Concepts

1. Introduction to User RPL and System RPL

The basic user of the HP48 can use User RPL. It’s easy to learn, and it’s the first language you can use to program your HP.

Each time you use a User RPL command it checks the arguments, so it’s a rather safe language. You should not lose any data when using it.

If we look at the HP’s internal software, we’ll discover that each User RPL command is in fact divided into several simpler commands, each one of which does a single (usually) and simple thing. User RPL is divided internally into elementary commands, which we call System RPL. Each one of these System RPL commands usually ends up calling machine code, which is executed directly by the HP’s processor, the Saturn.

To help you understand, look at this:

You

¯

User RPL

System RPL

Machine language

¯

Saturn microprocessor

The HP48 gives you three development languages. User RPL is safe and easy, but the slowest of all. System RPL is faster because no checks are made, so you must take care of all argument at the beginning, but then you no longer need them as you feed data to hungry commands. Finally, we have assembly language, which produces machine language. This is the fastest code, directly executed by the processor, and of course it gives total control over the HP.

If you want to learn System RPL, knowing User RPL will be enough. All you will need is a complete list of all System RPL commands, called entry points, inside the ROM.

Assembly language is not related to User RPL or System RPL, so you’re going to learn something really different here. Assembler doesn’t have all the commands which are available to the System RPL coder.

It is not a complex language, as its commands are simple and do very elementary things; what may seem complicated is that you will need to write a lot of "elementary commands" to do more complicated things than just crashing your HP. ;)

What you’ll win is the fastest code around, as well as lack of sleep, but that’s being a coder.

 

2. Assembly language and machine language

"Mnemonic" is the name given to each elementary command. It’s something very simple, so it reminds us what it’s used for (mnemosis ® memory, so "mnemonic").

1. The binary base and nibbles

We are going to do some math. Don’t be afraid: even if you are bad at math you can do assembly language anyway. :)

As you learned, machine language is composed of series of zeroes and ones. That is because processors work internally with components that let electrons go through or not. In the computer world, 1 usually means an electrical current exists and 0 usually means one does not exist.

So, the Saturn processor keeps the bits as four-bit packets, which are called nibbles. This is something you must remember. The traditional spelling is "nybble;" however, the spelling "nibble" has become more common in recent years so we will spell it with an ‘i’ for the purpose of this book.

Let’s start from something we know: the decimal base. We have ten digits so we can easily use the decimal base.

The decimal base is not the only one. Sailors use the sexagesimal base, base 60, because they use hours, minutes, and seconds.

When you type the decimal number 10 on your HP, it displays "10." In fact, the HP internally translates it to bits, and the Saturn processor works with them, thus under the binary base. (I will teach you later that the Saturn processor is able to work with both our decimal base and its binary base, so it’s a very good processor isn’t it?!)

Decimal base means we use 10 symbols to write numbers:

0 1 2 3 4 5 6 7 8 9

Under the binary base, we only have two symbols:

0 1

So, zero in binary base is zero, one is one, and two?

Well, if we use the symbol "2" under the decimal base to represent the number two, we will use "10" under the binary base to represent the number two. In other words, we are going to combine zeroes and ones to represent numbers using the binary base.

The binary base is linked very closely to Boolean algebra, which will be briefly discussed later.

So, here is a small table of decimal numbers and their corresponding form in binary base:

Decimal base	Binary base
0	0
1	1
2	10
3	11
4	100
5	101
6	110
7	111
8	1000
9	1001
10	1010
…	…

You must look at the way the 0’s and 1’s are combined to form numbers, and then be able to continue. We will discuss this in detail over the next few pages, as it is important to learn. It’s not something easy, so don’t feel bad if you have trouble understanding.

Now, we are going to kept bits as packets of four bits, because that’s the way the Saturn likes.

Four packet bits are called nibbles, so a nibble is composed of four bits. Assembly language coders have some special words when they speak about bits and the different sizes used to group bits.

When four bits are packed together, it is called a "word of four bits." If 32 bits are packed together, it becomes a "word of 32 bits."

How many values can a packet of four bits have? It’s easy: we use a power of two to calculate:

2⁴ = 16

So four bits packed together create a nibble, and:

A nibble can have 16 different values.

Let’s calculate another one: how many values can a word of 64 bits have?

2⁶⁴ = 1.8 * 10¹⁹

A lot. :-)

 

2. Converting from binary to decimal

We are going to examine two nibbles kept together, which is called a "byte."

4 bits ® a nibble

8 bits ® a byte

We are going to give each bit a number, from right to left, and will call that the "rank" of a bit. Here is an example: I have two nibbles together (a byte) which are: 01100101, so we have:

rank: 7 6 5 4 3 2 1 0

bits: 0 1 1 0 0 1 0 1

As you see, I have started the "rank" by zero, and then I count from right to left. Each bit has a rank, a specific rank. Each bit has also something special.

The rank is used to know which "weight" the bit has. What does that mean? It means that each bit is, according to its rank, an exponent of base 2. Let me explain; look at this:

rank: 7 6 5 4 3 2 1 0

bits: 0 1 1 0 0 1 0 1

weight: 2⁷ 2⁶ 2⁵ 2⁴ 2³ 2² 2¹ 2⁰

What I call weight is the value of the bit in the decimal base. Here is an example: what is the binary value 00100110 in decimal mode? Let’s write it:

rank: 7 6 5 4 3 2 1 0

bits: 0 0 1 0 0 1 1 0

weight: 2⁷ 2⁶ 2⁵ 2⁴ 2³ 2² 2¹ 2⁰

Now, the "weight" of each bit can be calculated, and we’ll find the decimal value! Let’s do it:

We are going to multiply each bit by its weight, and we add each together, that is:

(0 * 2⁷) + (0 * 2⁶) + (1 * 2⁵) + (0 * 2⁴) + (0 * 2³) + (1 * 2²) + (1 * 2¹) + (0 * 2⁰)

that is: 0 + 0 + 32 + 0 + 0 + 4 + 2 + 0 = 38

Use your HP to check: press [MTH] [BASE] [BIN] and then type the number: #00100110b. Now, press [DEC] and you get:

#38d

It works! It’s cool, isn’t it? :-)

Now, you are able to convert a binary number to a decimal one. You write them down, you give each one a rank, from right to left and from zero to the last one. Then, you write the "weight" of each bit, and you can calculate the decimal value.

What is the maximum value of a nibble? Two nibbles?

With two nibbles we have:

rank: 7 6 5 4 3 2 1 0

bits: 1 1 1 1 1 1 1 1

weight: 2⁷ 2⁶ 2⁵ 2⁴ 2³ 2² 2¹ 2⁰

That is:

(1 * 2⁷) + (1 * 2⁶) + (1 * 2⁵) + (1 * 2⁴) + (1 * 2³) + (1 * 2²) + (1 * 2¹) + (1 * 2⁰)

That is:

128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255

So a byte (two nibbles) can go from 0 to 255, that is 256 different values.

Remember!! 0 (zero) is a value too!

And with a nibble we have:

rank: 3 2 1 0

bits: 1 1 1 1

weight: 2³ 2² 2¹ 2⁰

That is:

(1 * 2³) + (1 * 2²) + (1 * 2¹) + (1 * 2⁰)

That is:

8 + 4 + 2 + 1 = 15

So with a nibble we can go from 0 to 15, that is 16 different values.

To get the decimal form of a binary integer, we multiply each bit’s value by 2^bitrank and we add all values.

 

3. Most significant bit and least significant bit

This is something important, so don’t skip it.

As I have shown you, each bit has a weight. The bit that is the rightmost has a rank of zero, and the bit that is the leftmost has the highest rank (rank n-1 when we have n bits).

This means that each bit has a different weight in the final value.

The bit that is rightmost is called the Least Significant Bit, or LSB.

The bit that is leftmost is called the Most Significant Bit, or MSB.

In the nibble, the LSB and MSB are there:

rank: 3 2 1 0

MSB LSB

In the byte, the LSB and MSB are there:

rank: 7 6 5 4 3 2 1 0

MSB LSB

 

4. Fractional numbers

This is a little trickier.

A fractional number has two parts: the integer part before the fraction mark (a decimal point or comma, depending on region), and the fractional part after the fraction mark.

But…how can we have fractional numbers using bits?

We are going to give each bit a negative exponent weight.

Instead of:

rank: 3 2 1 0

bits: 1 1 1 1

weight: 2³ 2² 2¹ 2⁰

we have for fractional numbers:

rank: 3 2 1 0

bits: 1 1 1 1

weight: 2^-3 2^-2 2^-1 2^-0

Please note: ( 2^-3 ) is in fact: ( 1 / 2³ )

( 2^-2 ) is in fact: ( 1 / 2² )

What is the value of 0.0110 in decimal?

rank: 3 2 1 0

bits: 0 1 1 0

weight: 2^-3 2^-2 2^-1 2^-0

That is:

(0 * 2^-3) + (1 * 2^-2) + (1 * 2^-1) + (0 * 2^-0)

That is:

0 + 0.25 + 0.5 + 0 = 0.75

 

5. Calculating using base 2

In this section you’ll learn how to add, subtract, multiply, and divide two binary values. This is going to help you understand how the Saturn works. :-)

 

1. Adding

You will follow these rules:

0 + 0 = 0 ® no carry

0 + 1 = 1 ® no carry

1 + 0 = 1 ® no carry

1 + 1 = 0 ® carry

Here is an example:

0101

+ 1101

-----

10010

When I have 1 + 1, I put a zero, and I move the carry 1 to the left. I work here from right to left, adding two bits each time.

 

2. Subtracting

You will follow these rules:

0 - 0 = 0

0 - 1 = -1 ® negative result

1 - 0 = 1

1 - 1 = 0

So here I need to explain to you how a negative number is represented using the binary base.

 

3. Negative numbers

There are various ways to do negative numbers. I am going to explain two that are important for you to know. You’ll use either one or the other in your own programs: which one you use will depend on whether you want to let the processor do calculations for you or make it work the way you want, thereby ruling the beast!

 

1. The signed binary: the first method

We are going to use the most significant bit here (now you know why I told you about the MSB and the LSB!).

When the MSB is zero, the value is positive. When the MSB is one, the value is negative.

And we use all the other bits available to code the value.

This is called a "signed binary," and it’s my favorite one (don’t ask why).

If we have one nibble, a positive zero is: 0000

a negative zero is: 1000

(yes, there is a +0 and a -0 when using signed binaries!)

If you remember what I told you before, a nibble can go from 0 to 15, thus 16 possible values. Though there are still sixteen possible values, here we cannot use 0 to 15 because we use the MSB to tell if it’s positive or negative. So a nibble goes:

Binary	Decimal
from 0000 to 0111 when it is positive	from positive zero to 7 when it is positive
from 1000 to 1111 when it is negative	from negative zero to -7 when it is negative

If we use a byte (two nibbles):

Binary	Decimal
from 00000000 to 01111111 when it is positive	from positive 0 to 127 when it is positive
from 10000000 to 11111111 when it is negative	from negative 0 to -127 when it is negative

Remember!! We have two zeroes here: a negative zero and a positive zero.

 

2. The complement of 2: the second method

0000 1011 —inverting bits® 1111 0100

1. Multiplying

1. Dividing

1. Hexadecimal base

Unlike the decimal base, which uses base 10, and binary, which uses base 2, the hexadecimal base uses base 16. Why are we going to use base 16? As we’ve seen, the Saturn prefers to keep the bits in packets of four bits, which we call a nibble.

Earlier, we learned that a nibble can have up to sixteen different values. Here they are in their binary form:

Decimal	Binary	Hexadecimal
0	0000	0
1	0001	1
2	0010	2
3	0011	3
4	0100	4
5	0101	5
6	0110	6
7	0111	7
8	1000	8
9	1001	9
10	1010	A
11	1011	B
12	1100	C
13	1101	D
14	1110	E
15	1111	F

When we use the decimal base, we have ten symbols and combine them to represent numbers. We have also studied the binary base, which combines zeroes and ones to compose numbers.

As the hexadecimal base has 16 symbols, we have to find 16 symbols; we use the first ten ones from 0 to 9, and then we use the first 6 letters of the alphabet: A, B, C, D, E, F

And we are going to combine those digits and letters to represent numbers. What is cool here is that four bits can be represented by a single symbol in the hexadecimal mode. :-)

This base is used in all computers I know about, or at least systems using similar processors, as some old processors used the eight symbol octal base instead.

 

2. Converting from hexadecimal to decimal

When we have a number in its hexadecimal form, we can give its numbers "ranks" like we did for the binary numbers. The exponents are just different (and produce bigger numbers).

Let’s look at five nibbles under their hexadecimal form. Why five? Because the Saturn processor uses five nibbles to give each nibble in memory a position, five nibbles are required to have a value that can be used as an address, to get information from memory, or to write memory there.

My hex number is #ABCDE and I want to get its decimal value. I would write:

rank: 4 3 2 1 0

hex: A B C D E

weight: 16⁴ 16³ 16² 16¹ 16⁰

It’s quite easy: as we are using the hexadecimal base, we are going to give each nibble a weight.

The "weight" of a nibble of rank n is: 16ⁿ

Example: what is the hexadecimal number #1AB0F in decimal?

We have here:

rank: 4 3 2 1 0

hex: 1 A B 0 F

weight: 16⁴ 16³ 16² 16¹ 16⁰

Now, all we have to do is multiply the nibble by 16^rank. Here we go:

Value = (1 * 16⁴) + (A * 16³) + (B * 16²) + (0 * 16⁰) + (F * 16⁰)

Don’t be confused because we have letters here rather than only numbers: because we are using the hexadecimal base, we will often find letters in numbers.

If you prefer, ( B * 16² ) is in fact: ( 11 * 16⁴ )

So we calculate values, and get:

(1 * 65536) + (10 * 4096) + (11 * 256) + 0 + 15 = 109 327

So #1AB0Fh = 109 327

You can check that using your HP. Type the number 109327 and then type [MTH][BASE][R®B]

R®B is a command that will turn a real to a binary integer. You have to make sure you are using hexadecimal notation; there should be a square dot in the [HEX] menu field. If not, press [HEX] so your binary integers are shown as hexadecimal values.

Try using R®B to turn reals to hexadecimal numbers, and then you can use B®R to turn the binary integer numbers back into reals.

 

3. Writing groups of four bits (nibbles) using hexadecimal

So, how do we write our nibbles using hexadecimal digits? We know a nibble, with four bits, can have 16 different values, and we have 16 symbols with the hex base, so we just to have to convert the four bits to the hex form.

What if there are more than four bits? Example: I have a 12-bit binary number, and I want to convert it to hex.

The trick is to separate bits into groups of four, from right to left.

For example, let’s use the number 0111 1011 0101.

To avoid a complex (and boring as math is) calculation, we won’t work with all 12 bits at once, but will instead cut them into packets of four bits. Now, we are going to convert each 4-bit packet to its hexadecimal value:

0111 ® 7

1011 ® B

0101 ® 5

(I gave you a table earlier, but as there aren't many symbols, you can write down numbers from 0 to 15, then their binary form, and then their hex value)

So I know the number:

0111 1011 0101 (binary) is #7B5h

This way we are able to easily convert very big binary numbers.

But...what if we don't have a multiple of four bits? No problem: we add enough zeroes to the left side of the number to get a multiple of four bits.

Example: I want to convert the number 011101 from binary to hexadecimal.

I’m going to separate it into groups of four bits, but obviously, there are not enough numbers:

01 1101

I will add two zeroes to the left-most packet in order to have a multiple of four bits in my number:

01 1101 becomes 0001 1101

Because they are leading zeroes, the value has not changed. :-)

Now I can convert each four-bit packet into its hex form:

0001 ® 1

1101 ® D

So we have 011101 (binary) ® #1Dh

 

4. Is all that number crunching needed?

Of course, we have an HP, so we could use the available functions to convert from binary to hex in any way we want. But it’s important to know how bits are encoded and used to represent numbers.

When your knowledge and programming skills increase, you will find some logical functions (described in the part after the next part) very useful for checking some values, using what we will call "masks."

A "mask" is a set of bits, which we will then use to check values of one or more bits.

I will tell you how a mask can be useful when we start using the HP’s keyboard and reading keys from it.

When I first started learning, I didn’t like bits and conversions. You may not care for learning them either, because after all, your HP can do that for you, right?

Wrong! You’ll just end up more confused than you would normally have been. You’re best off learning how to do it in your head, or you’ll get it all wrong.

Go back and reread the previous sections if you are at all confused. Even if you are bad at math you’ll be able to understand this.

 

5. The BCD: "Binary Coded Decimal"

This is the part I disliked most when learning. But it’s best to know it, especially if you want to pop reals from the stack.

The Saturn processor works with 4-bit packets called nibbles. We have learned that it stores them using a very cool format called hexadecimal. So when we want the processor to add two values, it will consider those as hexadecimal values: if we ask it to add 9 and 9, the Saturn won’t give us a result of "18" but rather "12" because 18 = #12h.

But we humans (or whatever you may be ;) prefer the decimal base, and the Saturn processor has been designed so it can also work with decimal numbers.

I told you it’s a cool processor, and quite powerful, even if it’s small and so hard to swallow (gulp! I ate my second one today).

When the Saturn is asked to do calculations using base 10 numbers, it uses a special mode called BCD.

BCD means Binary Coded Decimal

A nibble, which has four bits, can have 16 values. But when we will use the BCD mode, we will keep our numbers inside our decimal-base 10 form.

Pay attention to the way that BCD codes numbers in the following table. Remain calm, and you’ll see it’s not so difficult, okay? :-)

Decimal	Nibble (four bits)	BCD
0	0000	0000
1	0001	0001
2	0010	0010
3	0011	0011
4	0100	0100
5	0101	0101
6	0110	0110
7	0111	0111
8	1000	1000
9	1001	1001
10	1010	0001 0000
11	1011	0001 0001
12	1100	0001 0010
13	1101	0001 0011
14	1110	0001 0100
15	1111	0001 0101

As you can see here, there is no change between the nibble/bits value and its value with BCD when under ten.

But, when we reach the value of ten, the BCD can no longer increase with a single set of four bits, so we must add another set of four bits. We will start over using the new set of four bits, just like we did on the previous set. Notice how we go from 9 to 10 and how we continue up to 15.

When using BCD, each decimal number uses four bits. We use four bits to count from zero to 9, but "10" is written with two digits, so we have to use eight bits to code the value using BCD.

See, it’s not so complicated. It may look strange, but this is not the point we have to pay attention to. :o)

 

6. Converting a decimal to its BCD form

When you want to convert a decimal number to its BCD form, all you have to do is read the number from left to right and write down each number in its binary form:

If I have the number 934, what is its BCD form?

9 ® 1001

3 ® 0011

4 ® 0100

So 934 in BCD form is 1001 0011 0100

See? It’s not difficult at all. The BCD looks complex but isn’t really.

You must be cautious: the BCD binary form is not the same as the binary form.

The number I used for this example below is 934. Here you have its BCD binary form and its binary form:

BCD: 1001 0011 0100

binary: 0011 1010 0110

Don’t mix the two together like I did at first (yep!).

 

7. Usual BCD and "Extended BCD"

The form of BCD I have explained is the usual one, called the "Compacted BCD." There is another form of BCD called the "Extended BCD."

In the Extended BCD, instead of using four bits per digit, eight bits are used. For example, the number 11 would be coded as follows:

Compacted BCD: 0001 0001

Extended BCD: 00000001 00000001

When using Extended BCD, values can go from 0 to 99 by using one byte (two nibbles) whereas the Compacted BCD can only go from 0 to 9!

So the BCD used by the Saturn processor is not only cool, but clever :-))

(now, look at your HP, and tell it you love it...)

 

8. Calculating using BCD

Storing numbers is cool, but working with them is even cooler! However, because of the way BCD codes numbers, some nibbles are not allowed.

The Saturn will help us a lot, because not only can it store BCD numbers, but it can also perform calculations with them. All we have to do is tell the processor to be in BCD mode and then use it. It’s easy! :-)

There are two important things when using BCD: when a nibble gets an overflow, and when a carry appears and has to be moved.

 

1. When a nibble overflows

What will happen if I add 16 twice using BCD?

0001 0110 (16 under BCD form)

+ 0001 0110

­­­­­­­­­

0010 1100

Problem: we cannot have 1100, as it is not allowed when using BCD.

 

2. When a carry needs to be moved

When we add two 1 bits, we have a carry, and we must move one bit to the left and write a zero. For example, 0001 + 0001 = 0010

But, when using BCD, the carry cannot move to the left as one would like.

 

9. Logical operations

This is an important part. We will meet operations like OR, AND, and others, like XOR. (Julien Meyer, or SunHP, wrote a prayer to the XOR function, as it is useful in games and graphics, and he prays to it each night. ;)

Processors are made using logical operations. I will only discuss simple ones here, but when using much more complex ones, processors are able to do really complex tasks.

Just think about your COS key. When you press it, the RPL operating system checks if there is an argument, then whether it’s a valid one, and finally calls one or more machine language operators, which result in the processor moving bits from places to places, with logical operators working over them. Fascinating! :-)

George Boole (1815-1864) published a book in 1847 called "Analyse mathematique de la logique," or something like "Logic Analysis of Mathematics." The most important part of his work is about logic. Some of our words are translated into algebraic components, in order to create rules for the thinking processes of calculations. We call this Boolean algebra.

In Boolean algebra, we have two values: 0 and 1. :-)

0 is said to be "false" (the value "false")

1 is said to be "true"

Because we’re speaking of logic, we have to understand the concepts of false or true inside the Boolean algebra. Each value gets one purpose: 0 is used for false, and 1 is used for true.

Electronics extensively use this concept of our beloved Boole. Get a drawing of him, along with Newton and Einstein, and put them on your wall! If you don’t, you’ll never be a good coder. ;)

So, we’re going to use the bits 0 and 1

Zero means "false," and in electronics, it’s found when there is no voltage.

One means "true," and it’s found when there is voltage in the circuit.

Because we use bits here, we have two values that we are able to compute:

0 is the "complement" of 1

1 is the "complement" of 0

Because the complement is inverting the bits (I’m speaking of the "complement of 1" also called "restricted complement". It’s not the "complement of 2" we used to store negative values; take a look at the first part if you are confused).

We have three basic logic operations. From two of those we are able to create all the other ones that exist (or maybe I should say "those we use and have discovered").

French name	English name	Symbol used
ET	AND	·
OU	OR	+
NON	NOT	-

When a value has been negated using NOT, a line is drawn over its name, like:

_

NOT A = A

And that value is called "A-barre" in French. I think it’s called "A-bar" in English.

 

1. Logical OR

It can also be called "logical adding."

I am going to show you what is called a "truth table." Each logical operation has one. On the left part we put letters, like A, B, C and so on, for each bit in input. On the right part, we have one S (the result) or several results, when there are several outputs.

The OR is done between two bits, first one is A, second one is B, and in S you have the result of the OR between the two bits.

OR Truth Table:
A	B	S
0	0	0
0	1	1
1	0	1
1	1	1

The logical OR can also be written using an equation:

S = A + B

Note: the logical OR is not the addition we saw when we studied binary numbers.

0101 + 0011 = 1000

0101 OR 0011 = 0111

As you now see, OR result is 1 either if A or B are 1 or if both of them are.

 

2. Logical AND

It is also called the "logical product," but it is NOT multiplication.

The equation is written: A · B = S

 

Here is the truth table for AND:

AND Truth Table:
A	B	S
0	0	0
0	1	0
1	0	0
1	1	1

Here the result is 1 only if both A and B are 1.

 

3. Inverting

We just invert the bit. The equation is written:

_

S = A

Notice that there is a bar above the letter.

INVERT Truth Table:
A	S
0	1
1	0

 

4. NOT OR (also called: NOR)

This is using NOT and OR together. When doing a NOR, output is set to 1 only if all inputs are set to zero.

The equation for NOR is:

___

S = A+B

NOR Truth Table:
A	B	S
0	0	1
0	1	0
1	0	0
1	1	0

 

5. AND NOT (also called: NAND)

This uses AND and NOT together. When using NAND, it’s the inverse of NOR. In other words, the output is always 1 unless both entries are set to 1.

The equation for NAND is:

___

S = A·B

NAND Truth Table:
A	B	S
0	0	1
0	1	1
1	0	1
1	1	0

 

6. EXCLUSIVE OR (also called: XOR)

This one is extensively used when dealing with graphics. The result is 1 if either A or B is one, but only if one of A or B is one. If A and B are both set to 1, we get zero.

The equation is:

A XOR B = (A OR B) - (A AND B) (note that the minus sign is not a logical operation)

XOR Truth Table:
A	B	S
0	0	0
0	1	1
1	0	1
1	1	0

It is cool because a graphic object is, when in memory, a set of bits. When we want to draw a graphic, we can XOR its bits to the actual graphic on screen. Then, if we do an another XOR at the same position, it makes the graphic object disappear! :-)

We’ll see that later, so be patient. :-)

 

10. Review: Numerical bases

Some people said they either didn’t read the part on bases or read it too quickly. I understand, because I did the same when I started learning myself. But, a minimum amount of knowledge is required. To be able to recognize hexadecimal and binary forms is mandatory. When I tell you about masks and how to compose them, both binary and hexadecimal information will be required, because we’ll write down bits to create our required mask, convert to hexadecimal, and then load it into C or A for using it to test another register’s value.

You don’t need to know how to convert values from binary to hexadecimal, and such conversion things, but knowing each bit’s weight seems of importance to me.

As a quick review, there are four bits in a nibble and each has a weight. No matter how many bits there are, they are numbered from right to left.

 

11. Review: Calculations

Divide field f by 2: CSRB f

Divide field f by 16: CSR f

Multiply field f by 2: C=C+C f

Multiply field f by 16: CSL f

1. Programming Tools

1. An assembler: HP-ASM

Before you can start writing code, we must discuss some tools that you’ll need. In the beginning, the first coders had to write their assembly programs on paper, then they translated the assembly instructions to their hexadecimal form, and from there they created Code object strings.

Today we have better tools. You write your program in a string, and a compiler called an "assembler" will do the job of checking your code (after all, everyone makes mistakes sometimes) and producing the Code object.

I have tried several assemblers. Jazz is interesting but is too big for most users. I want people using a G to be able to code, and this introduction is aimed at everyone, including those using S and G models. Never let anyone tell you an SX or

GX is needed to code. They’re stupid. ;)

Here I will use the HP-ASM 1.1 syntax. This tool is the G/GX adaptation of ASM Flash from Phong Nguyen, who, according to Jean-Yves, was 8 years old at that time of writing it. For the purpose of this document, HP-ASM is a synonym for ASM Flash.

HP-ASM is really fast. Jazz’s ASS command is several times slower, and what takes half a second in HP-ASM needs up to one or several using ASS. It’s not very crucial, but impressive.

You may get HP-ASM, for the HP48 G, G+, and GX, from this location:

http://www.hpcalc.org/programming/asm/hpasmgx.zip

ASM Flash, for the HP48 S and SX, is available here:

http://www.hpcalc.org/programming/asm/asmflash.zip

The hpasmgx.zip file is a ZIP file, and inside it there are two versions of HP-ASM for the G series. If you have an S or SX, you should get ASM Flash instead.

HP-ASM is available in both versions 1.0 and 1.1. Version 1.0 is 8606 bytes and works quite well. The other version, version 1.1, is 9124 bytes long. Version 1.1 has some new instructions and perhaps other things.

This library contains an assembler that will create code objects from your sources. In this tutorial version 1.1 commands are described, but 1.0 commands are very similar (®ASM instead of ASM, for example). Because the difference in size between 1.0 and 1.1 is only about 600 bytes, you should get 1.1.

If you have a GX with lots of free uncovered RAM, you can choose Jazz, which has many additional features, such as a disassembler, a debugger, and System RPL support. I won’t use its syntax here, as it uses a slightly different syntax. People using G models or S models don’t have enough space to use it. Because this introduction is not just for GX people but rather for everyone, I’ll use HP-ASM syntax.

HP-ASM syntax is compatible with the Meta Kernel’s MASD assembler, so this tutorial is valid for the Meta Kernel as well. In addition, MASD has a few really cool features for programmers. If you own the Meta Kernel, read its manual for more information.

 

2. HP-ASM Commands

Here are the HP-ASM commands in its library menu:

ASM: Takes a string as an argument and returns an assembled object (either a code object or a string with hex codes)

ED: Not an editor, but if you make a mistake, by pressing ED, the source string is edited, and you are moved to the beginning of the line where an error was found. When you use ED, it calls the standard editor, the one given by the HP. ED can be modified so it calls the editor you want if you know a little System RPL, but that’s beyond the scope of this book.

OPT: Allows options to be selected. When a menu key is pressed, the menu key contents toggle from one option to another.

CODE/HEXA: If CODE the assembler produces a Code object; if HEXA it pushes a string that contains the hexadecimal values corresponding to the generated code.

0-15/1-16: When using 0-15, nibbles are numbered from 0 to 15, otherwise from 1-16. This will affect the use of the P register, like P= n, CPEX, C=P, P=C, and the bit mnemonics, like CBIT, ABIT, and tests involving P, and HS. With assembly language, we start counting at 0, so 0-15 is strongly preferred, meaning the first nibble of a register is number #0h. Advice: keep it set to 0-15 all the time.

HP/PC: This affects which operator symbols are used. The HP has extended ASCII characters for comparisons that are not compatible with a PC’s extended ASCII. Choosing HP uses these HP characters, and choosing PC uses PC-compatible two-character standard ASCII symbols: #, >= and <=. For example, the "not equal to" sign is "=" with a slash through it when HP is set and the pound sign (#) when PC is set.

JMP/UNJ: When JMP is chosen, the assembler checks all jumps and calculates them. If you select UNJ, then the jumps to labels are not calculated, and thus not verified. It’s a good idea to leave this checked. Only select UNJ it if you are compiling a small piece of code extracted from a larger project with the intent of calculating the bytes it takes without having the assembler error out with a bad jump.

ON/OFF: When compiling a very big program, you can turn the display off and the compilation will run about 13% faster. When OFF is selected, the screen will turn off while assembling; ON keeps it on. It’s a good idea to keep the screen off when assembling large sources.

EXIT: Exits the OPT menu.

 

3. Assembling code with HP-ASM

The Code objects produced by HP-ASM (or any other assembler, like Jazz, J-ASM, ASM Flash, and MASD) are fast because the HP’s Saturn processor directly executes them.

We don’t code using bits because that would be too difficult. Assembly language uses mnemonics, with one mnemonic for each instruction available on the processor. An assembler like HP-ASM translates these mnemonics into machine language, which is what is found in hexadecimal form inside the Code objects.

The HP48’s RPL cannot control what happens when we use Code objects, so we must code well, or otherwise drain our batteries recovering programs we lost (or for some of us, being happy to have one or more RAM cards).

HP-ASM syntax is not HP’s syntax, but rather the one used by French programmers for some time. It’s like other tools, such as DEV and TC, so it’s a part of history. :-)

You will put your code inside a string. Because the internal HP editor is not very fast (and misuses memory like I have never seen) I recommend that you use an external editor. MiniWriter will work very well on G models. It would be nice if Jean-Yves were to release a MiniWriter that uses the 8-pixel font rather than the minifont. That would be the perfect and smallest editor to be used on S/G for use with ASM-Flash (S models) or HP-ASM (G models).

There must be one instruction per line inside the string that you give to the assembler. You can add comments using the percent symbol (%). Everything that follows a % until the carriage return is then considered a comment.

The last symbol in the text file should be the "at" sign (@); the assembler will then know this is the end of the source. This symbol is produced by [ALPHA][Right-Shift][ENTER].

The assembler is case-sensitive, which means that "Label" is different than "LABEL". When you name your labels, either write them all uppercase or all lowercase. Choose a style of writing, and stick to it to avoid confusion.

To go to the next line, do [Right-Shift][.]. (The state of the Alpha mode doesn’t matter, as it’s the same either way.)

 

4. Additional HP-ASM features

This is a summarized version of the English documentation included with ASM Flash.

 

1. The linker

This is something really cool. If you divide your sources inside several parts, you can ask the compiler to compile each part and then produce the final Code object. If you have two sources, ONE and TWO, you just put inside of your program:

'ONE

'TWO

@

The ' symbol is used to place the contents of a file in the HOME directory (or the current directory perhaps?) into your source.

If an error is found, it tells where.

 

2. Directives

A directive is the ‘!’ symbol followed by an OPT value; if you want your code to be compiled with the HP option ON, you just put inside of it:

!HP

By simply inserting a ‘!’ followed by a name from the OPT menu, you can temporarily turn on or off any of the options from your source code string. It can be done anywhere inside of your source: some parts can use PC comparison operators, and other parts HP ones, if you want.

 

3. Macros

Those are not really macros like coders are used to, but they’re cool anyway. You can compile code and reuse it already compiled, or insert a GROB or any kind of data inside of one of your programs. We will need to write a program to create macro-able objects, and it should be useful when we start the graphics part. See below for that program.

 

5. A fast text editor

http://www.hpcalc.org/apps/editors/strwrt44.zip

http://www.hpcalc.org/apps/editors/minwrt12.zip

http://www.hpcalc.org/apps/editors/ted32.zip

http://www.hpcalc.org/apps/editors/fonts/ufl102.zip

1. The Saturn Processor

1. Saturn registers

Here is a diagram of what is inside the Saturn processor:

D0			R0
D1			R1
			R2
A			R3
B			R4
C
D					OUT		IN
RSTK						PC
						ST
						HS

 

As you can see above, there are several parts, each inside its own box. Each part has a name, like D0, D1, RSTK, etc.

These are internal components of the Saturn processor, and they are used to make the processor do what you want.

First, where is the processor inside the HP? Not only is it connected to the memory (working upon information stored in memory), but it’s connected to the keyboard and the buzzer as well!

So we have two important parts: first, the processor, which is also called the CPU, meaning Central Processing Unit; and second, the memory.

A simple explanation is that an assembly program reads information from memory (or an input device), modifies it with simple operations (typically logical or algebraic), and then writes back to memory or to an output device.

So the work of the Saturn processor is for it to run instructions, which are programs, working with data in memory.

 

1. Processor registers

Inside the processor there are small areas that, like memory, are able to store information in the form of nibbles. There are three kinds of registers: some are called "pointers," some are simply called "registers," and others are called "save registers."

 

1. Pointer registers

The Saturn processor has two pointer registers: D0 and D1.

Each pointer register can store 20 bits. If we divide that by 4 (to get four-bit packets, or nibbles) we get 5. This means that, hardware speaking, the Saturn has two pointer registers, and each can receive five nibbles to "point" something in memory.

For example, if I want to read a nibble stored at the address ABCDE, I will put that address into D0 or D1 using this assembly instruction:

D0= ABCDE or D1= ABCDE

Now if I read nibbles, I will read them at the memory address ABCDE.

Thus an address is something that has five nibbles, so the Saturn processor can "point" to any nibble in RAM or ROM from #00000h to #FFFFFh, so we have 1 048 576 nibbles (one nibble being four bits). We will learn more about memory later.

There is another pointer register called PC. PC means "Program Counter." It is a very important register: it contains the address in memory of the current instruction being executed. The processor uses it to know where it is, and mostly, where it’s going. :-)

 

2. Counting bytes, KB

1. Addressable space

How much memory space is the Saturn able to access? We know the processor has two pointer registers: D0 and D1, and each can have a five-nibble value inside. Five nibbles can have 1 048 576 different values. Because the HP48 works with nibbles, we can access 1 048 576 nibbles, or 524 288 bytes. Divide that figure by 1024, and what do you get? Good! 512 KB.

So the Saturn, at any moment of its execution, can only manage 512 KB of memory. (Later we’ll learn there are tricks to manage more than 512 KB.)

This is called the addressable space.

 

2. Working registers

1. Save registers

1. The fields of working registers

We know working registers can have nibbles inside of them. Their size is 64 bits, or 16 nibbles.

Oftentimes we don’t need to work with all 16 nibbles of a register. Perhaps we want to work with only five nibbles, two nibbles, or maybe even only one nibble.

What we call a field is a part of a working register. If the register is 16 nibbles wide, we can, for example, call a five-nibble wide section a "field" of the working register.

The Saturn processor already has predefined fields, so it’s easier for us to work.

Before we begin learning about fields, I want to tell you about a strange thing with the Saturn processor: nibble inversion. Stay awake for this part!! :-)

 

1. Nibble inversion

This is something that will be complicated for some. The Saturn inverts the order of the nibbles when reading from or writing to memory. What I call reading nibbles is moving nibbles from an address in memory to a working register, and writing being moving nibbles from a working register to an address in memory.

Working registers can store up to 16 nibbles. Each nibble inside the register will have a number, as you will learn in the diagrams below. Nibble number zero is the first one (the LSB nibble), and nibble number #Fh is the last one (the MSB nibble). The nibbles are numbered from right to left.

Here are the 16 nibbles of any working register:

F

E

D

C

B

A

9

8

7

6

5

4

3

2

1

0

Note that they are numbered from right to left, so the "start" of the register is the rightmost nibble, and the "end" (nibble #Fh) is the leftmost nibble.

Although we (except Arabic or Hebrew friends, and Chinese/Japanese writers) read from left to right, the Saturn starts moving nibbles from the LSB nibbles (nibble number 0, then 1, and so on).

Therefore, the Saturn processor "reads" and "writes" from right to left. For the Saturn, the first nibble is the rightmost.

Let’s consider our register C. It’s 16 nibbles wide, so we can imagine we have C like below:

F	E	D	C	B	A	9	8	7	6	5	4	3	2	1	0
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0

Now, think of this in memory:

Displacement	Address in memory	Nibbles
0	00100	1B01C
+5	00105	022F0
+10	0010A	00033

If I read 15 nibbles into the C register, starting at address 00100, C will contain the following values:

F	E	D	C	B	A	9	8	7	6	5	4	3	2	1	0
0	3	3	0	0	0	0	F	2	2	0	C	1	0	B	1

The nibble number #Fh has not been modified, but you can see that the Saturn loads nibbles from right to left. If we have 1B01C 022F0 00033 in memory we get 33000 0F220 C10B1 in our working register. (Notice that I removed nibble #Fh, as I am only working with 15 nibbles for this example). Remember that we read the contents of the register from right to left.

 

2. Available fields

The drawing below is extremely important, so you should learn it and be able to reproduce it from memory. I learned it the first time I saw it, following another coder’s advice, preventing me from having to search for this information all the time. To make it simple for you: learn this! :o)

W

S

M

X

A

XS

B

 

1. The W field

This field is easy: it’s the whole register of 64-bits.

If we give a number to each nibble, we start from 0 and go to 15, because we have 16 nibbles. W is all 16 nibbles:

F

E

D

C

B

A

9

8

7

6

5

4

3

2

1

0

¬ ————————————– W –————————————®

W means word (sometimes called "wide")

When we want an instruction to work with all 16 nibbles of a working register, we use the W field.

 

2. The A field

This is the most used field of all. It’s 5 nibbles wide, and of course:

A means address

It looks like this:

F

E

D

C

B

A

9

8

7

6

5

4

3

2

1

0

¬ ——— A ———®

Please remember that the first nibble is 0, not 1. So when we think of the A field, we have five nibbles: the first one is 0, the second one is 1, the third one is 2, and so on.

Don’t forget it’s from right to left.

 

3. The B field

This is another very useful field: it’s the byte one! :-)

As you know, two nibbles form one byte, so the B field is two nibbles wide:

F

E

D

C

B

A

9

8

7

6

5

4

3

2

1

0

¬ B ®

Do you still remember the MSB and LSB? We can say that the B field is a part of (or is) the LSB of the working register :-)

 

4. The X field

This field is 3 nibbles wide. It’s very useful to use with an another component of the processor: OUT.

OUT will be used to check a key or to produce a sound using the HP’s buzzer. OUT will get three nibbles of data, so the X field will be used with OUT. Very useful, and for other things too…believe me. ;-)

F

E

D

C

B

A

9

8

7

6

5

4

3

2

1

0

¬ — X —®

X = eXponent (see M field below)

 

5. The XS field

The XS field is the third nibble of the register, that is, the MSB of the X register.

XS = eXponent Sign

 

6. The M field

This is the Mantissa field, nibbles 3 to 14

This field comes from the way the HP71 handled numbers with its Saturn processor: S (described below) was the used for the sign, M for the Mantissa, and X for the eXponent.

Now you know why those letters are there. :-)

F

E

D

C

B

A

9

8

7

6

5

4

3

2

1

0

¬ ————————— M —————————®

 

7. The S field

The S field is the last nibble of the working register, number 15.

 

8. Field summary

1. The P register and WP

• When you want to read one nibble that is not the first one of the register, we load its position number into P, and then we read it. For example, if we want to read nibble number 8, we will do P=8 and then read one nibble there using the P field (I’ll show you how later).
• P defines the size of the WP field, from 0 to n, with n being the value of P. If you want to read or write m nibbles you do P=(m-1) and then use WP as the field.

1. Circular handling of numbers inside the processor

1. RSTK

RSTK means "Return STacK."

First, what is a "stack?" Hopefully, as HP users, we already use a stack when using our HP. The stack is used a lot in computers because of memory structure. This will change when 3D chips are introduced, and when HP will have eaten Intel and Microsoft, but let’s be patient until then, and keep that secret. ;)

The RSTK is a LIFO Stack. LIFO means Last In First Out.

Like our HP stack, if you enter a number onto RSTK, the first one to be popped out will be the last one that was put in.

To put it another way, it’s like pushing coins into a tube and removing them from the same hole they were put into. Another kind of stack is FIFO, or First In First Out. This is like a tube where we put coins on one side and we wait for them at the other hole: the first ones pushed into the tube will be the first ones to be recovered.

This RSTK is similar to our HP’s RPL stack. However, it’s limited in size: there are eight levels available, and each level has a fixed size: 5 nibbles.

This is used by subroutines. When you call a subroutine from an assembly language program, the processor records where we are, stores it into RSTK, and jumps to the subroutine. When the subroutine wants to go back to where it was called from, it pops the "return address" from the return stack and jumps to it. Because it is an address, we only need to have five nibbles per level on the RSTK stack.

Whenever an address is popped from the stack, the top level is replaced with zeroes. Also, the stack has something called "circular behavior", so after a stack overrun you can always read the last eight addresses. For example, suppose you write 1, then 2, then 3, 4, 5, 6, 7, 8, and 9 to RSTK. You can now read 9, 8, 7, 6, 5, 4, 3, 2, and 0. In other words, you read the eight remaining levels, plus a zero, as zeroes filled the stack as it dropped.

So the RSTK contains eight 5-nibble addresses. The interrupt system of the HP uses two levels when called, and sometimes a third level is used, so unless we don’t allow any interruptions, we will only be allowed to use five levels.

RSTK is useful for quickly storing temporary information. We’ll discuss this more later.

 

2. Flags: ST, HST, and Carry

Flags are special bits that can have two values: 1 or 0. When a flag is set, it has a value of 1. When a flag is clear, it has a value of 0.

 

1. Carry

This bit is a flag in itself. Each time an operation (like adding or subtracting, or when we get an overflow* on a register) has a carry, the carry bit is set to tell us that either a carry or an overflow has occurred.

* overflow is explained above. When we work with a field of a working register, if adding or removing a value makes us "go around" the carry is set to 1. If field A of C contains #FFFFFh, adding 1 to field A will put #00000h in field A of C, and the carry will be set to 1.

Also, each time we perform a test, if the test is true, the carry is set (set to 1), and if the test is false, the carry is cleared (set to 0).

When we perform a test, the processor will set or clear the carry. Next the carry bit is tested to determine what to do next.

 

2. ST (Status Bits)

The ST flags are composed of 4 nibbles. Therefore, we have 16 bits available, with each one being a flag.

As a coder, you are allowed to use flags 0 to 11. Flags 12 through 15 have special meanings and can be dangerous if misused.

Here are the meanings of bits 12 through 15:

bit 12: Forced wakeup request (overrides DeepSleep)

bit 13: Set if an interrupt has occurred

bit 14: Set if an interrupt is pending

bit 15: Set to 1 if interrupts are enabled or 0 if interrupts are disabled

ST bits 0 through 11 may be given whatever values you want. You can later test them, with each one being a flag with the meaning you give it. :)

The Saturn handles bits 12-15. We’ll use bit 15 sometimes, but you should not mess with the others.

 

3. HST (Hardware Status Bits)

This flag has one nibble, or four bits. The Saturn uses these four bits to handle special hardware events. The four bits are:

bit 0: XM (eXternal Module missing)

bit 1: SB (Sticky Bit)

bit 2: SR (Service Request)

bit 3: MP (Module Pulled)

There is only one bit that can be set to 0 by us: XM. We’ll use an instruction called RTNSXM (ReTurN and Set XM).

You’ll find the SB to be useful: when we shift bits around a register, if a bit goes from the MSB to LSB, or from LSB to MSB, the Saturn will turn the SB to 1 to warn us there has been a loss of information during the bit shift. This will happen if bit 1 of the LSB goes around and gets into the MSB nibble.

 

3. OUT and IN

The Saturn processor is able to exchange information with the keyboard and produce sounds. Two registers inside the processor are thus used: OUT and IN. They have specific sizes:

OUT is 3 nibbles wide (12 bits)

IN is 4 nibbles wide (16 bits)

When we want to test a key, we’ll put a value (from a table of values) into a register like C, and send it to the OUT register. Then electrical power will be given to lines in the keyboard (from 1 to all), and if a key is pressed, the result is put into the IN register. We’ll read that value, as it will tell use whether a key was pressed, and if so, which one. :-)

 

4. How the processor works: life of an instruction

1. What is a processor cycle?

1. Saturn Instruction Set

1. Working register instructions

 

1. Loading a value inside a register

You can use LC or LA to load from 1 to 16 nibbles inside A or C. There are no instructions to load a value into B or D, so we will have to first load a value into A or C and then move it into B or D.

An important thing to consider when using LA or LC is the value of P. The value of P, when you will start a program, will be zero. You can change its value, but when you quit, you have to restore it to zero.

So if you modify P’s value (and you will, if you need to read the nibble n of a register or use WP) you have to pay attention to LA and LC instructions.

I have also shown you there is a circular loading of nibbles into registers. If we give P the value of E and load 6 nibbles using LC ABCDEF we will get:

1. The name of the mnemonic (here "LA" and "LC")
2. How it’s coded in memory, in hexadecimal
3. Which fields can be used or are used
4. Whether the carry bit is affected
5. The approximate number of cycles the processor needs to complete the instruction.

1. LA, LC

Mnemonic	Hex-form	Fields	Carry	Cycles
LA n..1	8082 n 1...n	according to P value	no	7.5+1.5n
LC n..1	3 n 1...n	according to P value	no	3+1.5n

1 is the first nibble being loaded and n the last one. You have examples of how nibbles are loaded above. LA and LC do not modify the carry, even if a circular loading appears.

As you see here, LC is faster than LA. It’s coded with fewer nibbles in memory. It’s not very important, unless some part of your code needs to go really fast (like everything linked to display, usually). If you need speed, use LC rather than LA.

n is the number of nibbles being moved. This piece of code:

LC 02A2C

will move 5 nibbles into the C register, and needs 3+1.5x5 cycles, or 10.5 cycles.

 

2. Setting a register to zero

Here we are going to learn how to set a register, from 1 to 16 nibbles, to zero. The first letter will be the letter of the register, or A, B, C, or D. Then, the equal sign (=) and 0 of course!!

To clear the whole C register (all nibbles), simply write:

C=0 W

:-)

Remember that W is word (or wide). It is the field that affects the whole register, or 16 nibbles!

Here are the fields, which were described in part 3:

W

S

M

X

A

XS

B

So if we now want to put all zeroes into the X field of register B, we will use:

B=0 X

Mnemonic	Hex-form	Fields	Carry	Cycles
A=0 f	D0 Ab0	A only P,WP,XS,S,M,B,W	no no	8 4.5+n
B=0 f	D1 Ab1	A only P,WP,XS,S,M,B,W	no no	8 4.5+n
C=0 f	D2 Ab2	A only P,WP,XS,S,M,B,W	no no	8 4.5+n
D=0 f	D3 Ab3	A only P,WP,XS,S,M,B,W	no no	8 4.5+n

What is f? It’s the field! :-)

The A field is treated separately than others, because the A field is used so often in the processor that it has specific hex forms.

Also, you will see that the "hex-form" column lists hex numbers, but sometimes, letters. You will use a table to know which letter is to be used, according to the field.

Example: I want to do A=0 S. The instruction is Ab0, and by using the table below you can find the value of b:

Field	a values	b values
P	0	8
WP	1	9
XS	2	A
X	3	B
S	4	C
M	5	D
B	6	E
W	7	F

Because there is a "b" you need to use the "b" column. Look for S, and you’ll find "C," so you know the instruction to do A=0 S is "AC0."

You will not need this information unless you intend to code a disassembler or an assembler. But now if you want to create one you have the info. :-)

As usual, "n" is the number of nibbles being cleared to 0.

Let’s code! :)

We are going to code something that sets the entire C register to zero and then quits. HP-ASM wants one instruction per line, so each time you write a complete instruction, you will have to move to the next line, like below:

C=0 W

A=DAT0 A

D0=D0+ 5

PC=(A)

@

I know, there are instructions here you don’t know yet, but let’s first compile it and run it, okay? If you don’t make any mistakes, you’ll get a Code object. :-)

Press EVAL, and it will run! The W field of the C register will clear, and then the code will end.

Now, I need to explain the last 3 instructions.

A=DAT0 A

You know that the Saturn processor has two pointer registers: D0 and DA. (It has PC too, but we won’t use it here.) If D0 points to an area somewhere, then DAT0 is the data there. It’s the same for D1. If D1 points to #ABCDE, we will use DAT1 to get nibbles from there.

Let’s say there are 5 nibbles:

Address	Nibbles
#80120h	02A2C00005

If we want to read, say, three nibbles from #80120h, and put them in A, we will code this:

D1= 80120

A=DAT1 X

First, we make D1 point to #80120h, and then we read three nibbles (field X) into A.

If we want to read 10 nibbles using C and D0, we do this:

D0= 80120

C=DAT0 10

(You can put a number in the field location, which is cool :-)

Now, let’s explain these instructions:

A=DAT0 A

D0=D0+ 5

PC=(A)

When a program (your program) is given control, some registers and some pointers are used by the HP:

D1 points to the first level of the stack

D0 points to the next object to execute

B points to the return stack of the RPL

D contains the free memory in 5-nibble blocks

When your program starts, those values are used. Sometimes we will have to "save" some register values, because if we lose B or D0, we’ll get into trouble (the HP will halt, or if you’re unlucky, crash).

D0 points to the next RPL object to execute. When we want to quit, we have to read the address of the next RPL object to run into A, that is:

A=DAT0 A

So now, A contains the address (5 nibbles read from where D0 points to, A being 5 nibbles wide).

Now that we have read it, we have to move D0 5 nibbles later. It is important to increment D0 to the next object. We are going to execute the current one, so the next instruction that will read from D0 must read from the good zone. :-) That’s why we increment D0 by 5 nibbles: we have read 5 nibbles, so we must move 5 nibbles later:

D0=D0+ 5

The last instruction jumps to that address, directly using the PC pointer. The Saturn processor, when it needs to know "where" to continue, will read from PC. So we make PC point to A, and the execution continues. Remember that the following code is the usual way to "return to RPL":

A=DAT0 A

D0=D0+ 5

PC=(A)

You will use this to quit your programs most of the time. :-)

Other small pieces of code will be given as we learn more Saturn instructions, like code to drop, swap, and so on.

 

3. Changing the value of a bit

We can change the value of any bit inside the first four nibbles of registers A or C (not B or D!). As you have learned, when a bit is equal to 1 it’s set and when equal to 0 it’s clear.

We will use the ABIT (for register A) and CBIT (for register C) instructions. When we want to set a bit, we use:

ABIT=1 n

CBIT=1 n

and to clear a bit:

ABIT=0 n

CBIT=0 n

where n is the number of the bit set to 1 or 0, and n may have values from 0 to 15 (number of the bit)

NOTE: Some people don’t like to start counting from 0, and prefer to count from 1. HP-ASM lets you choose. When you press its OPT command, the "B" key lets you choose between 0-15 (the usual way in computers) or 1-16. You can choose what you want. I will always use 0-15 here, so if you choose 1-16, you’ll have to adapt your sources.

Here are the mnemonics:

Mnemonic	Hex-form	Fields	Carry	Cycles
ABIT=0 n	8084n	bit number n	no	7.5
ABIT=1 n	8085n	bit number n	no	7.5
CBIT=0 n	8088n	bit number n	no	7.5
CBIT=1 n	8089n	bit number n	no	7.5

Example: I want to turn off the busy indicator when I launch my code. How would I do this?

First, you have to know that indicators are just bits stored in a certain area of RAM. By giving bits values of 1 we can turn on indicators, and by giving them values of 0 we can turn them off.

I will explain that now, so you can learn about these bits and special values.

At the address #0010Ch there is a nibble, and the value of its bits can be used to turn on or off some indicators:

Bit number	Function
0	busy indicator (1=on, 0=off)
1	transmit indicator (1=on, 0=off)
2	?
3	show indicators? (1=on, 0=off)

So if I want to turn off the busy indicator, I have to read the nibble at #0010C, set its bit number 0 to 0, and then leave.

Let’s do it!! :-)

First, we need to use D0 or D1 to point there. But the HP uses D0 and D1! D0 points to the next RPL object to execute, and D1 points to the first level of stack.

So we must "save" the value of D1 (or D0) and restore it before leaving.

I’m going to use C to read the nibble and A to save the value of D1, so I can have D1 point somewhere else.

To move the value of D1, we’re going to use an instruction we have not seen yet: AD1EX. This instruction moves the 5 nibbles in D1 to A, and the 5 nibbles of A to D1. After using it, the previous value of D1 will be kept in A. This instruction is used to exchange the contents of D1 with A and is explained later in this document. :-)

First, move the value of D1 to A:

AD1EX

Then, point D1 to #0010Ch, and read one nibble there:

D1= 0010C

C=DAT1 P

Why P? P is equal to zero, so when using P, it’s like using:

C=DAT1 1

In other words, it reads the first nibble of the memory at the location referred to by D1 and puts it in C. Now the value of bit 0 in C must be changed. We can use the instruction we have just learned:

CBIT=0 0

Write it back to memory:

DAT1=C P

(Instructions for reading and writing data are explained later, but I think you now understand how it works.)

Then give D1 its old value:

D1=A

and quit to RPL the usual way:

A=DAT0 A

D0=D0+ 5

PC=(A)

So the code to turn off the busy indicator and return to RPL, is:

AD1EX

D1= 0010C

C=DAT1 P

CBIT=0 0

DAT1=C P

D1=A

A=DAT0 A

D0=D0+ 5

PC=(A)

@

Of course, it goes very quickly. So, if we want to really see it happen, we have to store the code inside a variable and then wait for a key before we leave.

Compile that code, and store it under the name BOFF (Busy OFF). Next, run the following RPL program:

<< BOFF 0 WAIT DROP >>

and look at the busy indicator!! :-)

You will have << BOFF 0 WAIT DROP >> on the stack, and the busy indicator will be off. :-)

 

4. Exchanging two registers

We can exchange two register values. We can either exchange the whole register or only a smaller field of it.

Mnemonic	Hex-form	Fields	Carry	Cycles
ABEX f	DC AbC	A P,WP,XS,S,M,B,W	no no	8 4.5+n
BCEX f	DD AbD	A P,WP,XS,S,M,B,W	no no	8 4.5+n
ACEX f	DE AbE	A P,WP,XS,S,M,B,W	no no	8 4.5+n
CDEX f	DF AbF	A P,WP,XS,S,M,B,W	no no	8 4.5+n

The number n is the number of nibbles being exchanged between one register and the other.

NOTE: ACEX is the same thing as CAEX of course. HP-ASM wants you, when you have 2 registers to exchange, to put them in alphabetical order. This means you must write ACEX f rather than CAEX f, as it will not recognize CAEX f.

We know we cannot load a value into D because there is no LD, so we can load nibbles into C or A and then exchange them with C, like:

LC 124

CDEX X

This exchanges 3 nibbles between C and D, thus "moving" #124h into D. If you want to exchange two registers, you will use the W field, of course. :)

 

5. Copying a register into another