COURS 2.TXT

Languages:

English  • français

   ******************************************************************
   *                                                                *
   *            68000 ASSEMBLY COURSE ON ATARI ST                   *
   *                                                                *
   *                 by The Ferocious Rabbit (from 44E)             *
   *                                                                *
   *                          Lesson Number 2                       *
   *                                                                *
   ******************************************************************

   THE 'MAGIC' NUMBERS

   Let's first understand in a simple way how a computer works by
   placing ourselves in the following situation: we need to send
   messages to a person with whom we are separated (for example,
   messages at night between distant people).

   We have a flashlight, which we can turn on or off, that's it. We
   can give 2 messages: 1) the flashlight is off (e.g., everything is
   fine) 2) the flashlight is on (e.g., here come the police!)

   Let's delve into the 2 states of the flashlight:
                         On                     Off

   which boils down to: Power On               No power
   or: Power?             YES                    NO

   Power value?            1                      0

   Tests will be noted as 0 or 1 depending on the flashlight being on
   or off.

   Since we are rich, we buy a 2nd flashlight.
   So, we have 4 message possibilities:

               FLASHLIGHT 1        FLASHLIGHT 2

              Off                 Off
              On                  Off
              Off                 On
              On                  On

   Counting with 3,4,5,6 ... flashlights, we realize that it is
   possible to find a simple relationship between the number of
   flashlights and the number of possibilities.

   Number of possibilities = 2 to the power of the number of flashlights.

   So, we get the following table:
   Remarks are just there to give you a hint!

   Flashlights  Possibilities                 Remarks
   1             2
   2             4
   3             8            There are 8-bit computers ...
   4             16           and 16 bits...
   5             32           The ST is a 16/32 bits
   6             64           Amstrad CPC... 64!!
   7             128          or Commodore 128?
   8             256          In computing, the character coding
                              (letters, numbers, etc., using ASCII)
                              allows for 256 characters!
   9             512          A 520 has 512 KB of memory, and
                              Amstrad sells a PC1 512.
   10            1024         The memory size of my 1040!
   11            2048         That of my brother's Mega 2
   12            4096         That of a Mega 4. Also the number of
                              displayable colors with an Amiga.
   etc...
   16            65536        In GFA, an array
                              cannot have more than 65536 elements.

   If my 4 flashlights are off (0000), I am at possibility 0. If they
   are all on (1111), I am at 15 (because from 0 to 15 makes 16), so
   0000 --> 0 and 1111 --> 15.

   So, I have a book of 16 pages giving the possibilities of the 16
   possible lighting configurations, and my correspondent has the
   same. How do I send him the message from page 13?

   Since the smallest digit is on the right (we note digits in
   order hundreds, tens, units), let's arrange the flashlights.

   Flashlight number:  4       3       2        1
   a) I have only one flashlight (the 1st one); it's on, so I get the
   value 1. (I can only get 0 or 1)

   b) I have 2 flashlights (1 and 2), both on, I get the 4th
   possibility. So, I have the value 3 (since I count the values 0,1,
   2, and 3, which makes 4). Since flashlight 1 is at most the value
   1, I deduce that flashlight 2 is alone worth a maximum of 2.

   In fact,      flashlight 1 on --> value 1
                flashlight 2 on --> value 2
   So, both on together --> value 3 = 4 possibilities.

   Flashlight number:     4             3            2            1
   'increase'            8             4            2            1

   To send the message 13, I need to turn on flashlight 4
   (value of 8), flashlight 3 (value of 4), and flashlight 1 (value
   of 1).
   Flashlight            4      3         2       1
   Flashlight state      1      1         0       1
   Value                8  +   4    +    0   +   1 = 13

   So, we are counting in binary.

   In decimal: dec means 10, because a digit can take 10 values
   (from 0 to 9).

   In binary: bi = two because each digit can only take 2 values
   (0 or 1).

   Computing is an Anglo-Saxon field. A 'binary digit' in English is
   called a 'BIT'! So, a bit can be 0 or 1. It is the smallest
   computing unit because the correspondent to whom we send messages
   is, in fact, a computer. Instead of turning on flashlights, we put
   current on a wire or not. An 8-bit computer has 8 wires on which
   current is placed or not!

   To send messages, we will prepare flashlights with small switches,
   and when our flashlights are ready, we will turn on the main
   switch to send the current and thus turn on the intended
   flashlights at once.

   Through our 'flashlights', we will send messages to the heart of
   the machine (in the case of the ST, it is a Motorola 68000
   microprocessor) which has been manufactured to respond in a
   certain way to different messages.

   So, we prepare our flashlights, and then we turn them on. We have
   16 flashlights because the Motorola 68000 is a 16-bit
   microprocessor.

   Here is a 'program' (i.e., a sequence of orders) as it is at the
   level of turning on or off the current on the 16 wires. All the
   way to the left is the value of wire 16, and to the right is the
   value of wire 1. 0 = no current on the wire, 1 = current. The
   microprocessor is surrounded by multiple drawers (memory cells),
   and among the orders it can execute are 'go get what's in that
   drawer' or 'go put this in that drawer'. Each drawer is identified
   by an address (like each house), i.e., by a number.

   So, we will tell the microprocessor: go get what's at address
   24576, add to it what's at address 24578, and put the result at
   address 24580. We could replace 'at address' with 'at the address'.

   Let's turn on the 16 flashlights accordingly; this gives:

   0011000000111000
   0110000000000000
   1101000001111000
   0110000000000010
   0011000111000000
   0110000000000100

   A single glance is enough; it's a total mess! How do we make sense
   of a program like this? If we forget to turn on a single
   flashlight, it won't work anymore, and finding the error in such a
   listing, good luck!
   It's a mess!!!

   So, we have the option to represent this not in binary but in
   decimal. Unfortunately, the conversion is not convenient, and
   anyway, we end up with large numbers (visually, because their size
   as a number doesn't change, of course!) For example, the 3rd line
   gives 53368. So, let's convert differently by separating our
   binary numbers into groups of 4 bits.

   VOCABULARY NOTE:

   We will speak only English. All abbreviations in computer science
   are abbreviations of English words or expressions. Reading them in
   French requires memorizing their meaning. By reading them as they
   SHOULD be read (in English), these expressions give their
   definition. One example is T$, which is systematically read as T
   dollar! However, $ is not, in this case, the abbreviation for
   dollar but for string. So, T$ must be read AND PRONOUNCED as T
   string. String meaning 'chain' in English, T is therefore a string
   of characters. Obviously, reading T dollar means absolutely
   nothing! The only interest is that it amuses Douglas, the joyful
   Brit who programs with me!

   One binary unit is called a BIT (binary digit).
   4 units form a NIBBLE.

   8 units form a byte (which we will call by its English name,
   BYTE).

   16 units form a word (WORD).

   32 units form a long word (LONG WORD).

   Let's go back to our conversion by grouping our 16 flashlights
   (so our WORD) into groups of 4 (so into NIBBLES).

    0011        0000         0011         1000

   These 4 nibbles form our first word.

   Let's count the possible values for a single nibble.

   Nibble state 0000         value 0
           0001         value 1
           0010         value 2
           0011         value 3
           0100         value 4
           0101         value 5
           etc..
           1010         value 10
           STOP  it's over! 10 is 1 and 0, but we've already used
   them!
   Well, yes, but apart from 0,1,2,3,4,5,6,7,8,9, we don't have much
   at our disposal... Well, there's the alphabet!
   So, let's write 10 with A, 11 with B, 12 with C, 13/D, 14/E, and
   15 with F. So, there are 16 digits in our new system (from 0 to
   F). 'Dec' means 10, and 'Hex' means 6 (a hexagon), so Hex + Dec =
   16. Decimal = having 10 digits (0 to 9), hexadecimal = having 16!

   Our program becomes hexadecimal:
   $3038
   $6000
   $D078
   $6002
   $31C0
   $6004

   Clearer, but it's not there yet.

   NOTE: To differentiate between a binary number and a decimal or
   hexadecimal number, by convention, a binary number will be
   preceded by %, a hexadecimal number by $, and there will be
   nothing in front of a decimal number. So, $11 does not equal 11 in
   decimal but 17.

   Let's think a little. In fact, we wrote:

   'Go get what's there'
   'at address $6000'
   'add to it what's'
   'at address $6002'
   'put the result'
   'at address $6004'

   The microprocessor can, of course, pick from the thousands of
   memory cells in the machine, but it also has some on itself
   (small pockets, so to speak, in which it temporarily stores things
   it will need quickly). It has 17 pockets: 8 in which it can put
   data, and 9 in which it can put addresses. Data = DATA and
   address = ADDRESS, these pockets will be identified by D0, D1,
   D2,... D7, and by A0, A1,... A7, and A7' (we will see later why
   it's not A8, and the differences between these types of pockets).

   NOTE: The phenomenon of on/off and the same for ALL current
   computers. The number of 'pockets' is specific to the Motorola
   68000.
   So, the same number of 'pockets' on an Amiga or a Macintosh since
   they also have a Motorola 68000. On a PC or a CPC, the
   characteristics (number of flashlights that can be turned on
   simultaneously, number of 'pockets'...) are different, but the
   principle is the same. It's either on OR off.

   Let's modify our 'text', which now becomes.

   'move into your pocket D0'
   'what you will find at address $6000'
   'add to what you have in your pocket D0'
   'what you will find at address $6002'
   'put the result of the operation'
   'at address $6004'

   The machine is very limited, as by design, the result
   of the operation in the 3rd line will go into D0 itself, overwriting
   what is already there. To keep the value that was there,
   it would be necessary to copy it, for example, into pocket D1!

   Moving is called in English MOVE
   Adding is called in English ADD

   Our program becomes

   MOVE    what is at $6000   into  D0
   ADD     what is at $6002     to   D0
   MOVE    what is now in  D0 to $6004

   That is:
   MOVE    $6000,D0
   ADD     $6002,D0
   MOVE    D0,$6004

   We have just written a program in machine language.

   The fundamental difference with a program in any other
   language is that here, each line corresponds to ONLY ONE
   operation of the microprocessor, whereas PRINT "HELLO" will
   make it do a lot. It is obvious that our BASIC,
   being a 'mechanical' translator, has a translation that is likely
   to be approximate, and, although effective, it
   uses many more instructions (for the microprocessor)
   than are actually needed.

   It is also worth having a fond thought for the first
   programmers of the 68000 who initially created a program with 1s and
   0s, a program that only translated hexadecimal numbers
   into binaries before transmitting them to the machine. They
   then created, in hexadecimal, programs translating instructions like MOVE, ADD, etc., into binary...

   It was then enough to group several instructions of this
   type under another name (not directly understood by the machine) and
   to create the corresponding translators, thus creating
   'advanced' languages (PASCAL, C, BASIC...)

   So, we are going to be interested in programming or rather in the
   transmission of orders to the 68000 Motorola. How many orders can it
   execute? Only 56!!! (with variations, but still not many). Research
   (at a level far too high for us!) has indeed shown that it is faster to have
   few instructions doing little each and therefore executing
   quickly one after the other, rather than having
   many instructions (the microprocessor likely losing time
   searching for the one it was asked to do) or complex instructions.

   Work to be done: reread all this at least twice and then take a break
   to clear your mind before reading the rest.

   ADVICE: do not start the next part right away.
   Digest EVERYTHING that is written, as understanding
   every detail will serve you.

   A lamp, it's not much, but one burnt out and you
   will understand the mess it brings.
   Here, it's the same. The smallest thing not understood and you won't
   understand anything in the following. But if everything is understood, the
   following will be just as easy, and above all, logical.

Back to ASM_Tutorial