Useful
Inventions
Favorite
Quotes
Game
Design
Atari
Memories
Personal
Pages

# Assembly Language Programming

## Lesson 4: Binary Counting

By Robert M (adapted by Duane Alan Hahn, a.k.a. Random Terrain)

As an Amazon Associate I earn from qualifying purchases.

In previous lessons, I have hinted that there is a standard method for counting using bits. In this lesson, I will introduce that standard method. First, I want to reiterate that this is NOT the only way to count using bits. It is simply the most common method, and therefore has considerable support for it built into most microprocessors including the 650X processor Family used in most classic gaming consoles and computers from the late 70s and 80s.

Numbering Systems

I must assume that if you can read the lessons in this class and understand them, then you must be familiar with decimal numbers and basic arithmetic like adding and subtracting. All decimal numbers are made using the ten digits: 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9. When you write a decimal number larger than 9 you must use two or more digits like this: 123 which is one hundred and twenty three. The 1 in 123 does not represent 1 it represents 100. The 2 in 123 is not 2 it is 20. The 3 in 123 does represent 3. Thus we call the 1 the hundreds digit, the 2 the tens digit, and 3 the one's digit. Each digit in a large decimal number represents that digit multiplied by a power of 10 based on its position and summed together.

Thus (1 * 10^2) + (2 * 10^1) + (3 * 10^0) = 100 + 20 + 3 = 123 Ta-da!

We count numbers inside computers exactly the same way except that the numbering system in computers does not have 10 digits, it only has 2 digits: 0 and 1 (bits!). The numbering system that uses only 0 and 1 is called the binary numbering system or simply binary. Since it only has 2 digits the value of each binary digit in a large binary number is multiplied by a power of 2 instead of a power of 10 as we do for decimal numbers.

The following table shows the positional value of the first 16 bits in the binary number system, as a power of 2. Note that the first position is numbered zero and not one.

```
Bit position.

|

|    Bit value

|    |

2^0  = 1        => bit

2^1  = 2

2^2  = 4        => octet

2^3  = 8        => nybble

2^4  = 16

2^5  = 32

2^6  = 64

2^7  = 128      => byte

2^8  = 256

2^9  = 512

2^10 = 1024

2^11 = 2048

2^12 = 4096

2^13 = 8192

2^14 = 16384

2^15 = 32768    => word

```

Every computer in the world has a limited number of bits. When you use binary numbers in a computer program, you must decide how many bits you will use to store each number that your program must keep track of. For 650X processors, the most common numbers of bits to use will be 8 (byte) and 16 (word) because the processor works with data an entire byte at a time for each instruction (see opcodes in lesson 3). You can use any number of bits, but since 8 and 16 are so common, we will focus on them for the remainder of this lesson. The same rules will apply to binary numbers made of any number of bits.

This should not seem strange, as you can use any number of digits to represent a decimal number. If you don't need all the digits, then your number will have 1 or more leading zeros.

0000123 is the 7-digit decimal number 123, by convention leading zeros are not shown for decimal numbers, but they are always present nonetheless. The same is true for binary numbers.

In the real world you can write as big of decimal number as your writing surface will allow. In a computer, your writing surface is bits. If you do not have enough bits allocated/available to store a binary number then your program can not store that number and the information will be lost. Such an event is called overflow if the number is too big, or underflow if the number is too small. We will examine overflow and underflow in detail in the next lesson.

You may be curious to know what is the biggest binary number you can store in a byte or a word. You already learned the formula in lesson 2enumeration. Given N bits, you can store 2^N different values. Counting positive integers starts at zero not one, so N bits can store binary numbers from 0 to (2^N)-1

Example:

A byte has 8 bits so N=8. Therefore, a byte can hold unsigned positive integers from 0 to (2^8)-1=256-1=255. From 0 to 255.

Algorithm to Convert Decimal to Binary

To convert a decimal number to binary, you must repeatedly divide that number by 2. The remainder of each division is next binary digit in the binary representation of that decimal number. when there is nothing left to divide, the conversion is done.

Example: Convert 123 decimal to its binary equivalent.

```
123 / 2 = 61 with a remainder of 1 -------+

61 / 2 = 30 with a remainder of 1 ------+|

30 / 2 = 15 with a remainder of 0 -----+||

15 / 2 =  7 with a remainder of 1 ----+|||

7 / 2 =  3 with a remainder of 1 ---+||||

3 / 2 =  1 with a remainder of 1 --+|||||

1 / 2 =  0 with a remainder of 1 -+||||||

|||||||

123 Decimal = 1111011 binary

```

Algorithm to Convert Binary to Decimal

Any binary number can be converted to its decimal equivalent, which is often easier for humans to read and understand. To convert a binary number to decimal you must multiply each digit of the binary number by its positional value (see the first table above) and add the digit values together to form the decimal value.

Example: Convert 1111011 binary to decimal

```
1111011 binary

|||||||

||||||+- 1 * 2^0 = 1 * 1  =   1

|||||+-- 1 * 2^1 = 1 * 2  =   2

||||+--- 0 * 2^2 = 0 * 4  =   0

|||+---- 1 * 2^3 = 1 * 8  =   8

||+----- 1 * 2^4 = 1 * 16 =  16

|+------ 1 * 2^5 = 1 * 32 =  32

+------- 1 * 2^6 = 1 * 64 =  64

---

123 decimal

```

Binary Number Notation

Up until now I have been explicitly stating whether a written number is binary or decimal. As you can see it can become tedious to write "binary" or "decimal" after every number to clearly indicate the numbering system being used. Luckily, a handy shorthand notation exists for us to use to save time. For the remainder of this class I will always make use of this notation to indicate whether a number is binary or decimal.

Decimal Notation: A decimal number is written with no special notation at all. It is written the same way you have always written decimal numbers.

Binary Notation: All binary numbers shall be preceded by the % symbol.

Examples:

```
123 is decimal and %1111011 is its binary equivalent.

101 is decimal = One hundred and one.

%101 is binary = 4 + 1 = Five

```

MSB and LSB

Another aspect of binary notation is Most-Significant and Least-Significant Bits (MSB and LSB). By convention, a binary number is written from left to right, the same as a decimal number. The left-most digit of a number represents the greatest portion of the overall value of the whole number. It is the Most-Significant digit in the number. The right-most digit of any number represents the least portion of the whole value. It is the Least-Significant digit. Each digit in a binary number is a bit. Therefore, the Most-Significant Bit (MSB) of a binary number is the leftmost bit, and the Least-Significant Bit (LSB) is the right most bit.

Examples:

```   %100010010

^       ^

|       |

MSB     LSB

%10111010010010

^            ^

|            |

MSB          LSB

%100110

^    ^

|    |

MSB  LSB

```

Please get comfortable with this notation for binary numbers because you will be using it extensively when writing assembly language programs!

Odd or Even?

Please note that the LSB of a binary number indicates whether the number is odd or even. If the LSB is 1 then the number is odd. If the LSB is zero, then the number is even. In your code you may wish to take an action only on odd or even scanlines or frames. You will know if the scanline or frame is even or odd by examining the LSB of the scanline or frame counter.

You may have noticed that so far our discussion of binary has been restricted to positive integers. Computers can count negative numbers, so now we will begin to explore methods for representing negative numbers in binary. We will complete this discussion in Lesson 5.

Sign Magnitude Format

The first format for negative numbers we will explore is the sign-magnitude format. The format is easy to understand. For any given binary number add an additional bit to represent the sign of the number. If the sign bit is set, then the number is negative. If the sign bit is clear then the number is positive. The sign bit is the MSB of a sign-magnitude binary number.

Examples:

```
%0101 = %0 sign and %101  magnitude = 5

%1101 = %1 sign and %101  magnitude = -5

|

+-> The MSB is the Sign bit

```

There is a problem with this method of representing negative numbers. Can you see what that problem is?

The problem is with the number zero. Using this system there are 2 instances of zero, a negative zero and a positive zero. There is no such thing as negative zero, so this may not be the best method for representing negative numbers.

Two's Complement Format (Introduction)

An alternative to the sign-magnitude format is the two's complement format. Two's complement is superior to sign-magnitude (usually, but not always) because there is only one way to represent zero. Another advantage of two's complement is that when you add or subtract positive and negative numbers, the result is the correct number in two's complement format.

To really understand two's complement, you must know how to add and subtract binary numbers. We won't learn how to add and subtract binary numbers until lesson 5, so we will suspend further discussion of negative binary numbers until lesson 5.

Yes, you can represent REAL numbers in binary. REAL numbers can also be thought of as fractions (1.23 for example). This is an advanced topic and I don't want to go into it now because I believe it will confuse more people than it will help them to understand. You can write many, many programs without every needing to use REAL numbers. So just put them out of your mind for now.

Exercises

1.Convert 213 to binary.

2.Convert %00101100 to decimal.

3.Convert 1087 to binary.

4.Convert %1000010100011110 to decimal.

5.Take the LSB from each of the numbers below, in order from top to bottom, to create a new binary number. The LSB from the first number in the list should be the LSB of the new number. The LSB of the last number in the list is the MSB of the new binary number. What is the new binary number? Now convert that number to decimal.

%00110101

%01000101

%11100001

%10100110

%01001011

%01001110

%11001001

6.For each of the numbers below, convert them to decimal twice. The first time assume that the numbers are in unsigned positive integer format. The second time assume that the numbers are in sign-magnitude format.

1. %1000101
2. %0101010
3. %1100110
4. %0000010

7.What is the range of positive unsigned integers that can be stored in a word?

Bonus Questions:

1.For each number a-d in problem 6, is each number signed or unsigned? (Hint: refer to lesson 1).

2.Is the sign-magnitude format an Enumeration (lesson 2) or a code (lesson 3), and why?

1.Convert 213 to binary.

```
213 / 2 = 106 with a remainder of 1 ---------+

106 / 2 = 53  with a remainder of 0 --------+|

53 / 2  = 26  with a remainder of 1 -------+||

26 / 2  = 13  with a remainder of 0 ------+|||

13 / 2  = 6   with a remainder of 1 -----+||||

6 / 2   = 3   with a remainder of 0 ----+|||||

3 / 2   = 1   with a remainder of 1 ---+||||||

1 / 2   = 0   with a remainder of 1 --+|||||||

%11010101 binary = 213 decimal.

```

2.Convert %00101100 to decimal.

```
%00101100

||||||||

|||||||+--- 0 * 2^0 = 0 * 1   =   0

||||||+---- 0 * 2^1 = 0 * 2   =   0

|||||+----- 1 * 2^2 = 1 * 4   =   4

||||+------ 1 * 2^3 = 1 * 8   =   8

|||+------- 0 * 2^4 = 0 * 16 =   0

||+-------- 1 * 2^5 = 1 * 32  =  32

|+--------- 0

+---------- 0

0 + 0 + 4 + 8 + 0 + 32 + 0 + 0 = 44 decimal.

```

3.Convert 1087 to binary.

1087 / 2 = 543 with a remainder of 1 543 / 2 = 270 with a remainder of 1

270 / 2 = 135 with a remainder of 0

135 / 2 = 67 with a remainder of 1

67 / 2 = 33 with a remainder of 1

33 / 2 = 16 with a remainder of 1

16 / 2 = 8 with a remainder of 0

8 / 2 = 4 with a remainder of 0

4 / 2 = 2 with a remainder of 0

2 / 2 = 1 with a remainder of 0

1 / 2 = 0 with a remainder of 1

So 1087 decimal = %10000111011 binary.

4.Convert %1000010100011110 to decimal.

```
%1000010100011110

|    | |   ||||

|    | |   |||+---- 1 * 2^1 = 2

|    | |   ||+----- 1 * 2^2 = 4

|    | |   |+------ 1 * 2^3 = 8

|    | |   +------- 1 * 2^4 = 16

|    | +----------- 1 * 2^8 = 256

|    +------------- 1 * 2^10 = 1024

+------------------ 1 * 2^15 = 32768

2+4+8+16+256+1024+32768 =  34078 decimal

```

5.Take the LSB from each of the numbers below, in order from top to bottom, to create a new binary number. The LSB from the first number in the list should be the LSB of the new number. The LSB of the last number in the list is the MSB of the new binary number. What is the new binary number? Now convert that number to decimal.

%00110101

%01000101

%11100001

%10100110

%01001011

%01001110

%11001001

The LSB is the rightmost digit of each number, so the new binary number is: %1010111 which in decimal is: 64+0+16+0+4+2+1 = 87

6.For each of the numbers below, convert them to decimal twice. The first time assume that the numbers are in unsigned positive integer format. The second time assume that the numbers are in sign-magnitude format.

a.%1000101

unsigned = 64 + 0 + 0 + 0 + 4 + 0 + 1 = 69 decimal

signed = (-1) * (0 + 0 + 0 + 4 + 0 + 1 ) = -5 decimal

b.%0101010

unsigned = 0 + 32 + 0 + 16 + 0 + 2 + 0 = 50

signed = (+1) * ( 32 + 0 + 16 + 0 + 2 + 0 ) = 50

c.%1100110

unsigned = 64 +32 + 0 + 0 + 4 + 2 + 0 = 102

signed = (-1) * ( 32 + 0 + 0 +4 +2 +0 ) = -38

d.%0000010

unsigned = 2

signed = 2

7.What is the range of positive unsigned integers that can be stored in a word?

There are two basic ways to solve this problem. I will demonstrate both because I think it's important to see the relationships that make both methods arrive at the same answer.

1. The first approach is to realize that smallest unsigned integer is always zero. The binary value is unsigned so no bits are needed to store the sign of the number. In that case the largest unsigned number is the value of the binary number with all bits set to 1. A word has 16 bits, so the biggest unsigned binary number in a word is %1111111111111111.

If we convert that to decimal we get:

2^15 + 2^14 + 2^13 + 2^12 + 2^11 + 2^10 + 2^9 + 2^8 + 2^7 + 2^6 + 2^5 + 2^4 + 2^3 + 2^2 + 2^1 + 2^0 =

32768 + 16384 + 8192 + 4096 + 2048 + 1024 + 512 + 256 + 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 65535.

2. The second approach is to recall the formula from lesson 2 to find the maximum number of items that you can enumerate given N bits. The binary number system is just an enumeration of the natural numbers.

combinations = 2 ^ 16 = 65536 combinations. Recall however that the enumeration begins at 0, so that leaves 65536 - 1 = 65535 as the largest possible unsigned integer in a word.

Bonus Questions:

1.For each number a-d in problem 6, is each number signed or unsigned? (Hint: refer to lesson 1).

This is a trick question. The correct answer is both. As we learned in the first lesson bits represent whatever you the programmer say that they represent. They can represent both at the exact same time. It doesn't matter, they are only bits. Meaning is given by you the programmer with the logic of your code.

2.Is the sign-magnitude format an Enumeration (lesson 2) or a code (lesson 3), and why?

It is a code because enumerations represent only positive values from 0 to N.

We are rapidly descending from broad concepts to specific details in assembly programming. Most often, subsequent lessons will require an understanding of previous lessons. If you have questions after studying this material, do not hesitate to ask.

Other Assembly Language Tutorials

Be sure to check out the other assembly language tutorials and the general programming pages on this web site.

Amazon Stuff

Lesson 1: Bits!

Lesson 2: Enumeration

Lesson 3: Codes

Lesson 4: Binary Counting

Lesson 5: Binary Math

Lesson 6: Binary Logic

Lesson 7: State Machines

Easy 6502 by Nick Morgan

How to get started writing 6502 assembly language. Includes a JavaScript 6502 assembler and simulator.

Atari Roots by Mark Andrews (Online Book)

This book was written in English, not computerese. It's written for Atari users, not for professional programmers (though they might find it useful).

Machine Language For Beginners by Richard Mansfield (Online Book)

This book only assumes a working knowledge of BASIC. It was designed to speak directly to the amateur programmer, the part-time computerist. It should help you make the transition from BASIC to machine language with relative ease.

The Six Instruction Groups

The 6502 Instruction Set broken down into 6 groups.

6502 Instruction Set

Nice, simple instruction set in little boxes (not made out of ticky-tacky).

The Second Book Of Machine Language by Richard Mansfield (Online Book)

This book shows how to put together a large machine language program. All of the fundamentals were covered in Machine Language for Beginners. What remains is to put the rules to use by constructing a working program, to take the theory into the field and show how machine language is done.

6502 Instruction Set

An easy-to-read page from The Second Book Of Machine Language.

6502 Instruction Set with Examples

A useful page from Assembly Language Programming for the Atari Computers.

6502.org

Continually strives to remain the largest and most complete source for 6502-related information in the world.

NMOS 6502 Opcodes

By John Pickens. Updated by Bruce Clark.

Guide to 6502 Assembly Language Programming by Andrew Jacobs

Below are direct links to the most important pages.

Registers

Goes over each of the internal registers and their use.

Instruction Set

Gives a summary of whole instruction set.

Describes each of the 6502 memory addressing modes.

Instruction Reference

Describes the complete instruction set in detail.

Stella Programmer's Guide

HTMLified version.

Nick Bensema's Guide to Cycle Counting on the Atari 2600

Cycle counting is an important aspect of Atari 2600 programming. It makes possible the positioning of sprites, the drawing of six-digit scores, non-mirrored playfield graphics and many other cool TIA tricks that keep every game from looking like Combat.

How to Draw A Playfield by Nick Bensema

Atari 2600 programming is different from any other kind of programming in many ways. Just one of these ways is the flow of the program.

Cart Sizes and Bankswitching Methods by Kevin Horton

The "bankswitching bible." Also check out the Atari 2600 Fun Facts and Information Guide and this post about bankswitching by SeaGtGruff at AtariAge.

Atari 2600 Specifications

Atari 2600 programming specs (HTML version).

Atari 2600 Programming Page (AtariAge)

Links to useful information, tools, source code, and documentation.

MiniDig

Atari 2600 programming site based on Garon's "The Dig," which is now dead.

TIA Color Charts and Tools

Includes interactive color charts, an NTSC/PAL color conversion tool, and Atari 2600 color compatibility tools that can help you quickly find colors that go great together.

The Atari 2600 Music and Sound Page

Adapted information and charts related to Atari 2600 music and sound.

Game Standards and Procedures

A guide and a check list for finished carts.

Stella

A multi-platform Atari 2600 VCS emulator. It has a built-in debugger to help you with your works in progress or you can use it to study classic games. Stella finally got Atari 2600 quality sound in December of 2018. Until version 6.0, the game sounds in Stella were mostly OK, but not great. Now it's almost impossible to tell the difference between the sound effects in Stella and a real Atari 2600.

JAVATARI

A very good emulator that can also be embedded on your own web site so people can play the games you make online. It's much better than JStella.

batari Basic Commands

If assembly language seems a little too hard, don't worry. You can always try to make Atari 2600 games the faster, easier way with batari Basic.

Atari 2600 BASIC

If assembly language is too hard for you, try batari Basic. It's a BASIC-like language for creating Atari 2600 games. It's the faster, easier way to make Atari 2600 games.

In Case You Didn't Know

Did you know that Trump's rushed experimental rona jab has less than one percent overall benefit? It also has many possible horrible side effects. Some brainwashed rona jab cultists claim that there are no victims of the jab, but person after person will post what the jab did to them, a friend, or a family member on web sites such as Facebook and Twitter and they'll be lucky if they don't get banned soon after. Posting the truth is “misinformation” don't you know. Awakened sheep might turn into lions, so powerful people will do just about anything to keep the sheep from waking up.

Check out these videos:

What is causing the mysterious self-assembling non-organic clots?

If You Got the COVID Shot and Aren't Injured, This May Be Why

Full Video of Tennessee House of Representatives Health Subcommittee Hearing Room 2 (The Doctors Start Talking at 33:28)

H Word and I Word = Good

Take a look at my page called The H Word and Beyond. You might also want to look at my page called Zinc and Quercetin. My sister and I have been taking those two supplements since summer of 2020 in the hopes that they would scare away the flu and other viruses (or at least make them less severe).

B Vitamins = Good

Some people appear to have a mental illness because they have a vitamin B deficiency. For example, the wife of a guy I used to chat with online had severe mood swings which seemed to be caused by food allergies or intolerances. She would became irrational, obnoxious, throw tantrums, and generally act like she had a mental illness. The horrid behavior stopped after she started taking a vitamin B complex. I've been taking Jarrow B-Right (#ad) for many years. It makes me much easier to live with.

Unfermented soy is bad! “When she stopped eating soy, the mental problems went away.” Fermented soy doesn't bother me, but the various versions of unfermented soy (soy flour, soybean oil, and so on) that are used in all kinds of products these days causes a negative mental health reaction in me that a vitamin B complex can't tame. The sinister encroachment of soy has made the careful reading of ingredients a necessity.

If you are overweight, have type II diabetes, or are worried about the condition of your heart, check out the videos by Ken D Berry, William Davis, and Ivor Cummins. It seems that most people should avoid wheat, not just those who have a wheat allergy or celiac disease. Check out these books: Undoctored (#ad), Wheat Belly (#ad), and Eat Rich, Live Long (#ad).

Negative Ions = Good

Negative ions are good for us. You might want to avoid positive ion generators and ozone generators. A plain old air cleaner is better than nothing, but one that produces negative ions makes the air in a room fresher and easier for me to breathe. It also helps to brighten my mood.

Never litter. Toss it in the trash or take it home. Do not throw it on the ground. Also remember that good people clean up after themselves at home, out in public, at a campsite and so on. Leave it better than you found it.

Climate Change Cash Grab = Bad

Seems like more people than ever finally care about water, land, and air pollution, but the climate change cash grab scam is designed to put more of your money into the bank accounts of greedy politicians. Those power-hungry schemers try to trick us with bad data and lies about overpopulation while pretending to be caring do-gooders. Trying to eliminate pollution is a good thing, but the carbon footprint of the average law-abiding human right now is actually making the planet greener instead of killing it.

CO2 is Greening The Earth

The Climate Agenda

How to Wake Up Normies

Interesting videos:

Charlie Robinson Talks About the Best Way to Wake Up Normies

Georgia Guidestones Explained

The Men Who Own Everything

Disclaimer

View this page and any external web sites at your own risk. I am not responsible for any possible spiritual, emotional, physical, financial or any other damage to you, your friends, family, ancestors, or descendants in the past, present, or future, living or dead, in this dimension or any other.

Use any example programs at your own risk. I am not responsible if they blow up your computer or melt your Atari 2600. Use assembly language at your own risk. I am not responsible if assembly language makes you cry or gives you brain damage.