Pl2 INTERRUP.DOC

From Atari Wiki
Jump to navigation Jump to search

------------------------
INTERRUPTIONS and SYSTEM

VARIABLES

------------------------


Before starting to talk to you about interrupt-driven programs, let's study:

*** SYSTEM VARIABLES ***
-------------------------

- SYSTEM VARIABLES are various pieces of information that are available to us for reading and writing, located at the beginning of the second KB of our ST's RAM. (The location in RAM varies if you have a MEGA ST or an ST with the operating system (the TOS) not in ROM, but it does not vary between different versions of ROM)

- To access these variables, you must first go into SUPERVISOR MODE, otherwise beware of crashing... (Bus error: 2 bombs!)
  System variables are either BYTES or WORDS or LONG VECTORS (L-M).

- We will use some of these SYSTEM VARIABLES, they greatly influence the functioning of the ST:

  Here are the addresses where these different variables are located as well as their names, sizes, and uses:

  The names below are the standard names given by ATARI to these variables, the addresses assigned to them are only valid for STs with TOS in RAM.


  ADDRESS | NAME + SIZE | USE

  . $400 evt_timer (.L): This is a vector that points to the address $FCA648 (I give the addresses valid for ST with TOS in ROM) and allows the execution of periodic functions of the GEM.

  . $404 evt_critic (.W): This is a vector that points to the address $2A156 and is used when the operating system must handle an error from the floppy drive. (Drive not responding...)

  . $408 evt_term (.L): This is a vector that is used by _TERM type functions of Gemdos which are used to end the execution of a program.

  . $40C evt_xtra 5*(.L): 5 L-M are reserved for future applications...

  . $420 memvalid (.L): Semaphore for a valid memory controller configuration.

  . $424 memctrl (.B): If memctrl=4 the computer is a 520 ST
                       If memctrl=5 the computer is a 1040 ST
                       If memctrl=10 it's a MEGA ST
                       If memctrl=0 it's a 128 ST

  . $426 resvalid (.L): If it is worth $31415926 (that is, PI without the comma), the address pointed by resvector will be used as a vector during a RESET.

  . $42A resvector (.L): The vector used by resvalid during a RESET.

  . $42E phystop (.L): Address of the end of the physical video memory.

  . $432 _membot (.L): Address of the start of the memory area reserved for the programmer. (see organization of memory further on)

  . $436 _memtop (.L): Address of the end of this area ($78000 for a 520 ST or $F8000 for a 1040 ST)

  . $43A memval2 (.L): If memval2=$237698AA, the L-M confirms memvalid

  . $43E flock (.L): If flock is different from 0, the VBL is stopped (See further for VBL)

  . $440 seekrate (.W): Allows selecting the speed of movement of the floppy drive head from one track: 0=6 ms,1=12 ms,2=2 ms,3=3 ms

  . $442 _timer_ms (.W): Elapsed time between 2 calls from the timer, i.e., the speed of the beats of the internal clock. (in milliseconds) You will always find 20 ms or 50 Hz there (See further for TIMERS)

  . $444 _fverify (.W): If _fverify is different from 0, there is a writing test that is performed by the floppy drive: With each writing, it reads the written byte and compares it to the byte to be written.
                        In case of error, we get an error code

  . $446 _bootdev (.W): Contains the number of the floppy drive that loaded the operating system.

  . $448 palmode (.W): Flag indicating either that the system is in 50 Hz video mode (PAL) if palmode is different from 0 or that we are in 60 Hz video mode (Standard NTSC)

  . $44A defshiftmd (.W): Contains the screen resolution in which we are if we switch from a High-resolution screen to a Color screen. (0=low,1=medium)

  . $44C sshiftmd (.W): Contains the screen resolution in which we are: 0=LOW,1=MEDIUM, 2=HIGH

  . $44E _v_bas_ad (.L): Contains the address of the beginning of the logical video memory. It is necessarily a multiple of 256

  . $452 vblsem (.W): If this value is zero, the VBL is no longer executed: See further for the VBL

  . $454 nvbls (.W): Contains the number of routines executed during the VBL (Logically 8)

  . $456 _vblqueue (.L): Vector that points to the addresses of the routines executed during the VBL

  . $45A colorptr (.L): If this L-M is different from 0, it is interpreted as the address of a new color palette.

  . $45E screenpt (.L): If this L-M is not zero, it will be interpreted as the address of the new physical video memory.

  . $462 _vbclock (.L): This is the VBL interruption counter (See the following chapter)

  . $466 _frclock (.L): Contains the number of VBL routines that are not blocked by vblsem.
                        This number is also used for the RANDOM function of the XBIOS to obtain a random number.

  . $46A hdv_init (.L): Vector that points to the hard drive initialization routine in $FC0D60

  . $46E swv_vec (.L): Vector that points to the routine executed when a monochrome monitor is disconnected or connected (in $FC0020).
   
  . $472 hdv_bpb (.L): See function code $7 in the BIOS (Getbpb)

  . $476 hdv_rw (.L): Vector that points to the data writing and reading routines on a hard drive.

  . $47A hdv_boot (.L): Vector that points to the startup (BOOT) routine of the hard drive

  . $47E hdv_mediach (.L): Vector for the MEDIACH routine of the hard drive (To test if you change the disk: see MEDIACH code $4 in the BIOS)
  
  . $482 _cmdload (.W): If this variable is different from 0, the program named 'COMMAND.PRG' will be loaded as soon as the operating system is in place. This variable must be modified on the BOOT SECTOR.
  
  . $484 conterm (.B): This is a bit vector whose first 4 bits are used. If one of these bits is active, the function is used, otherwise it is disconnected.
                        Bit nr° 0: BEEP with each pressed key
                        Bit nr° 1: Keyboard repetition
                        Bit nr° 2: Ctrl+G gives a BEEP
                        Bit nr° 3: Allows you to adjust the BCONIN function of the BIOS.
   
  . $492 themd2 (.L): Address of the beginning of the available memory
     
  . $496 themd3 (.L): Address of the end of the available memory   
 
  . $4A2 savptr (.L): Address ($90C) that points to a memory area used to save the registers by the PROCESSOR after calling a BIOS or XBIOS function

  . $4A6 _nflops (.W): Contains the number of connected floppy drives.

  . $4A8 con_state (.L): Vector pointing to the code routines ('ESC' + 'value') for the effects of graphical text editing.

  . $4AC save_row (.W): Temporary memory for the text cursor position for the ESC + 'Y' function

  . $4AE sav_context (.L): Address pointing to a temporary memory used in case of an exception procedure.

  . $4BA _hz_200 (.L): The system timer that is incremented 200 times per second.

  . $4BC _the_env (.L): The default character string, positioned on 4 null bytes...
   
  . $4C2 _drvbits (.L): Bit vector representing the drives connected according to the active bit number.
  
  . $4C6 _dskbufp (.L): A 1 KB buffer used by disk operations.
  
  . $4CE _vbl_list 8*(.L): Vector that points to the addresses of the 8 routines that are executed in the VBL.

  . $4EE _dumpflg 8*(.L): Semaphore used by the Hardcopy function activated by pressing Alternate and Help.

  . $4F2 _sysbase (.L): Address of the beginning of the operating system ($FC0000 on STs with TOS in ROM)

  . $4FA _end_tos (.L): Address of the end of the operating system ($A100 on STs with TOS in ROM)   

  . $4FE exec_os (.L): Address of the beginning of the AES ($FD91D0)

  . $502 dump_vec (.L): Vector that points to the hardcopy routine of function 20 of the XBIOS.

  . $506 prt_stat (.L): Semaphore for the printer status

  . $50A prt_vec (.L): Vector for printing functions on the printer
  
  . $50E aux_sta (.L): State lookup vector used by a Hardcopy function

  . $512 aux_vec (.L): Output vector used by a Hardcopy function
  

  That is the list of these system variables, to modify them, you will just need to go into SUPERVISOR MODE and deposit the value you want. (Of course, you can also just content yourself to read the data that is deposited there...)


  Therefore, if you want to know the resolution:
  You will write:

* ;READING a SYSTEM VARIABLE:

      SUPER               ;MACRO to switch to SUPERVISOR MODE
      move.w $44C,d0 ;$44C=sshiftmd

  and You get the screen resolution in d0.W!!!


  If you want to change the color palette, you will write:

* ;WRITING on a SYSTEM VARIABLE:

      SUPER               ;MACRO to switch to SUPERVISEUR MODE
      move.l #PAL, $45A ;'PAL' address in $45A=colorptr

      DATA

  PAL DC.W $777, $007, $700, $070, $777, $777, $777, $777 ; the 16 colors
      DC.W $777, $777, $777, $000, $000, $123, $456, $789    

   and You change the color palette!!!


  This method applies to all system variables...

  These variables are very interesting for us because thanks to them, it is no longer necessary to call certain BIOS, XBIOS, or GEMDOS functions to obtain basic graphic effects such as changing the palette, getting the resolution... :
  This will be really very useful to us because these system variables are very easily modified or read. But the greatest interest we can draw from them is that modifying a system variable does not require the use of registers (SP or RETURN values), unlike BIOS, XBIOS, or GEMDOS functions...
  This will be really very useful when we make our first interrupt-driven programs...




                *** INTERRUPT-DRIVEN PROGRAMS ***
                -----------------------------------

- An interrupt-driven program is a program that must be executed periodically at regular intervals.
  Such a program will be the source of an EXCEPTION PROCESSING:
  It will be executed if a certain condition is met (in practice: after a certain amount of time has elapsed) and interrupted (Upon encountering instructions provided for this purpose) to be called again only when the condition is met again.

  An interrupt-driven program does not stop any function of the computer:
  It is managed entirely separately.
  It is quite possible that your main program performs a loop and AT THE SAME TIME, an interrupt-driven program executes without interrupting the main program!!
  It is this property that makes interrupt-driven programs so useful...
  (Not to say indispensable, because there are always interrupt-driven routines that are permanently activated for vital reasons...)
  We will study all this in detail very soon, don't panic!


- There are EXCEPTION ROUTINES that are executed by the operating system if a certain specific condition is met.
  They are programs that are executed exceptionally (hence their name!), i.e., if the condition that activates them is met.

  These exception programs are pointed to by a series of VECTORS located in the first KB of memory that point to the address of the relevant EXCEPTION ROUTINE.
  They are responsible for a number of vital functions of our MICROPROCESSOR.

  We can consider that interrupt-driven programs are exception programs.

  In practice:

  You have probably already seen a number of BOMBS display on the screen when you created a program that did not work correctly. These bombs serve to identify the source of the error for the programmer (or the user) and come from exception processing.
  There are 255 EXCEPTION VECTORS, and the number of bombs that display informs you of the number of the exception that has been solicited.


  Here are the various EXCEPTION VECTORS and their memory locations.
  They are LONG VECTORS (L-M) because they are ADDRESSES that point to the specific routines for the relevant VECTOR.

  VECTOR NUMBER: ADDRESS OF: ROUTINE and USE
                   THE VECTOR

     0           : $000      :SP after a RESET (.L)
     1           : $004      :PC after a RESET (.L)
     2           : $008      :BUS ERROR (2 BOMBS)
     3           : $00C      :ADDRESS ERROR (3 BOMBS)
     4           : $010      :ILLEGAL INSTRUCTION (4 BOMBS)
     5           : $014      :ERROR because a DIVISION BY ZERO has been detected. (The routine is actually just an RTE!)
     6           : $018      :Used by CHK
     7           : $01C      :Used by TRAPV
     8           : $020      :PRIVILEGE VIOLATION: An attempt has been made to touch data only accessible in SUPERVISOR MODE.
     9           : $024      :Address of the routine executed after each instruction in TRACE mode
    10           : $028      :LINEA emulation ERROR
    11           : $02C      :LINEF emulation ERROR
    12 to 14     : $030      :Reserved for future applications
    15           : $03C      :UNINITIATED INTERRUPTION
    16 to 23     : $040      :Reserved for future applications
    24           : $060      :Secondary INTERRUPTION
    25           : $064      :IPL 1
    26           : $068      :IPL 2
    27           : $06C      :IPL 3
    28           : $070      :IPL 4
    29           : $074      :IPL 5
    30           : $078      :IPL 6
    31           : $07C      :IPL 7
    32           : $080      :Used by TRAP #0
    33           : $084      :Used by TRAP #1 (GEMDOS)
    34           : $088      :Used by TRAP #2 (AES/VDI)
    35           : $08C      :Used by TRAP #3
    36           : $090      :Used by TRAP #4
    37           : $094      :Used by TRAP #5
    38           : $098      :Used by TRAP #6
    39           : $09C      :Used by TRAP #7
    40           : $0A0      :Used by TRAP #8
    41           : $0A4      :Used by TRAP #9
    42           : $0A8      :Used by TRAP #10
    43           : $0AC      :Used by TRAP #11
    44           : $0B0      :Used by TRAP #12
    45           : $0B4      :Used by TRAP #13 (BIOS)
    46           : $0B8      :Used by TRAP #14 (XBIOS)
    47           : $0BC      :Used by TRAP #15
    48 to 63     : $0C0      :Reserved
    64 to 255    : $100      :Available to the user, including:
    68           : $110      :TIMER D Interruption
    69           : $114      :TIMER C Interruption
    72           : $120      :TIMER B Interruption
    77           : $134      :TIMER A Interruption


  The details will come later.
  In practice, if your program displays 3 BOMBS before crashing, it means an address error has been detected, if it displays 4, it means an illegal instruction has been detected...


  Here is how the computer proceeds to execute an EXCEPTION ROUTINE:

  .Backup of SR in an internal register.
  .Switch to SUPERVISOR MODE by activating the S bit of SR.
  .Turn off TRACE MODE by extinguishing the T bit of the SR (Explanations on TRACE MODE later).
  .Search for the exception vector to use.
  .Stacking of PC and SR in the system stack.
  .Loading into the PC of the address contained in the chosen EXCEPTION VECTOR: Jump to the corresponding routine...
  .Execution of the exception program and return upon encountering an RTE (Return From Exception)
  .Restoration of SR and PC registers.

   It is quite possible to modify these vectors, just deposit the address (L-M) of the new routine to be executed at the address of the vector to be modified. (MOVE.L #NEW,$vector)
   This will have the effect of diverting the execution of the EXCEPTION ROUTINE towards your own routine...
   We will see this in detail when I talk about TRACE mode.


  But let's get back to our interrupt-driven programs.

  To manage several interrupt-driven programs at the same time, we will have to assign a PRIORITY LEVEL to our interrupt-driven program.
  The higher this PRIORITY LEVEL, the greater the importance given to our program in the hierarchy.

  The PRIORITY LEVEL of our program will be defined by the state of BITS I1, I2, I3 of the 'SR' STATUS REGISTER (Available ONLY in SUPERVISOR MODE!!)

   These 3 BITS allow to define 8 levels of priority.

  BITS    I1   I2   I0  =  % LEVEL  (or Interrupt Priority Level)

   %      1    1    1         7  
   %      1    1    0         6
   %      1    0    1         5
   %      1    0    0         4
   %      0    1    1         3
   %      0    1    0         2
   %      0    0    1         1
   %      0    0    0         0

   
   An INTERRUPT LEVEL (or Interrupt Priority Level :'IPL') 0 program will therefore be interrupted by any other program with an IPL ò 1, a
   program with IPL 1 will only be interrupted by a program with IPL ò 2
   but will remain indifferent to a program under interruption with IPL 0, and
   it will not be executed because its IPL is < 1 etc...

   LEVEL 0 is theoretically that of your program.
   (Lowest level)
   LEVEL 7 is theoretically the IPL level that will allow the interrupted program to be unaffected by any other interrupted program.
   (It could, for example, be the RESET, which has ABSOLUTE priority)
   
   . In practice, only levels 2,4, and 6 are used.

          IPL 2 is used by HBL
          IPL 4 is used by VBL routines
          IPL 6 is used by the MFP 68901 interruptions
      
  
   HBL: Horizontal BLank
   -------
   It is actually a routine executed after the SHIFTER 
   displays 1 horizontal line on the screen.
   Depending on the type of connected monitor, the routine is called every
   50 microseconds (50Hz) or every 64 microseconds (64 Hz) 
   A color monitor has 200 horizontal lines, the screen is 'refreshed' 50 times per second (50 Hz), so the HBL routine is
   called 10000 times per second in some conditions!
   This routine would greatly slow down the computer, which is why the HBL routine is not executed. (fortunately for us!)
   Indeed, from its first call, the routine will automatically set
   the IPL of our program to an IPL level 3: the routine will no longer be
   called because it has an IPL level 2...

   NB: It is possible to hijack this routine:
   --
       Just deposit the address of your routine in the 26th 
       EXCEPTION VECTOR that points to the HBL routine (.L) and
       reset the IPL of the program to a level < 2 ( By modifying  
       the I1,I2,I3 bits of the status register )
       Your routine should also end with the RTE instruction 
       (Return From Exception), but we will talk about this soon...
       (All in SUPERVISOR mode, don't forget!)


  VBL routines: Vertical BLank
  -------------------
  They have an interrupt level 4, so they have priority
  over the HBL interrupt.
  These routines are executed after a graphic screen (200 or 400 
  horizontal lines depending on the resolution) has been fully
  displayed on the monitor.
  They run 50 times per second (50 Hz).
   
  The VBL routines handle the change of the color palette ( Only after a complete image 
  has been drawn to avoid disturbing the image ), they test the change of 
  disks ...
  There are 8 routines in total, the number of available routines is
  contained in the system variable NVBLS and there is a vector 
  pointing to the 8 addresses of these routines, in VBLQUEUE.
  In reality, only 1 routine is executed: The 7 others are
  therefore available to us... 
  
    
  Interruptions of the MFP 68901 (Multi Function Peripheral)
  ------------------------------
  The MFP 68901 manages 16 interruptions, they have a priority level 6,
  so they have priority over the VBL and HBL interruptions.
  The 16 interruptions of the MFP 68901 also have different levels of priority
  among themselves!
  Thus, an MFP interruption of level 6 can only be interrupted by another interruption of level > 6, etc...

  Here are the different interruptions of the MFP 68901, classified by
  priority level (noted x on the ILP 6 of the MFP).


  LEVEL (x/6): The interruption
               
     15/6      : Detector of connection or disconnection of the high-resolution monitor
     14/6      : Ring indicator of the RS232 interface
     13/6      : TIMER A of the internal clock
     12/6      : Reception buffer of 1 character from RS232
                 intended for the user
     11/6      : Reception error of 1 character from 
                 the RS232 interface
     10/6      : Temporary transmission buffer of 1 character to 
                 the RS232
      9/6      : Transmission error of 1 character from the RS232
      8/6      : TIMER B and Line return counter
      7/6      : Routine control of floppy disk drives and DMA
      6/6      : Keyboard control routines (ACIAs) and MIDI port 
                 (Input and output)
      5/6      : TIMER C used by the YM-2149 (Sound), the keyboard and the
                 system synchronization counter (at 200 Hz)
      4/6      : TIMER D used for RS232 transmission and reception operations
      3/6      : Unused
      2/6      : Routine control of the CTS of the RS232
      1/6      : Routine control of the DCD of the RS232
      0/6      : Used by the BUSY of the CENTRONICS interface to create
                 a printer spooler.


  The above terms will not be explained, as you will not need to use them, so why complicate what is not
  already simple?

  We will still detail and explain the operating modes of the TIMERS, as it is their programming that will allow us
  to create our interruption programs.

  The TIMERS:

  As you have seen, there are 4 TIMERS:

  TIMER A, TIMER B, TIMER C, TIMER D.

  . TIMER A is entirely available to the programmer and has a priority
    level of 13 within the MFP (high!)
  . TIMER B is used as a line return counter but you can easily hijack it. It has a priority level of 8 within
    the MFP (IPL < TIMER A's IPL)
  . TIMERS C and D are responsible for a number of important functions 
    (sound management, keyboard...), hijacking them can therefore
    cause many problems...
    Moreover, they have a LOW priority level within the MFP, which is 
    why we will not use them to install our interruption programs.
 
    The programming of the TIMERS is done in a very particular
    manner:
    It will be necessary to program directly the registers of the CO-PROCESSOR MFP
    68901!!


The MFP 68901 REGISTERS:
---------------------------
There are 24 registers, each of size 1 BYTE:
These registers are located in memory starting at address $FFFA01
on ODD addresses.

These registers are an integral part of our ST's memory.
You can access all these registers in SUPERVISOR MODE by simply
placing the new value of the register at the corresponding address.
(As with system variables)

We will only use a small portion of these registers, here they are:

NR°) NAME: Indications (ADDRESS)
-------------------------------
1) GPIP: Flag for reading or writing to the parallel port
         ($FFFA01)

2) AER: Provides information about the operation mode of
         the interrupt
         ($FFFA03)

3) DDR: Assigns a transmission direction (input or output) to the bits
         of GPIP
         ($FFFA05)

4) IERA: Bit vector defining the IPL level of the MFP to block:
         IPLs from 15 to 8, See MFP interrupts above
         ($FFFA07)

         Bit 7: level 15
         Bit 6: level 14
         Bit 5: level 13
         Bit 4: level 12
         Bit 3: level 11
         Bit 2: level 10
         Bit 1: level 9
         Bit 0: level 8

5) IERB: Bit vector defining the IPL level of the MFP to block:
         IPLs from 8 to 0, See MFP interrupts above
         ($FFFA09)

         Bit 7: level 7
         Bit 6: level 6
         Bit 5: level 5
         Bit 4: level 4
         Bit 3: level 3
         Bit 2: level 2
         Bit 1: level 1
         Bit 0: level 0

6) IPRA: Automatically triggered bit vector that marks the IPL within
         the MFP (bit set to 1 = active IPL), see
         MFP interrupts for details on IPLs.
         ($FFFA0B)

         Bit 7: level 15
         Bit 6: level 14
         Bit 5: level 13
         Bit 4: level 12
         Bit 3: level 11
         Bit 2: level 10
         Bit 1: level 9
         Bit 0: level 8

7) IPRB: Automatically triggered bit vector that marks the IPL within
         the MFP (bit set to 1 = active IPL), see
         MFP interrupts for details on IPLs.
         ($FFFA0D)

         Bit 7: level 7
         Bit 6: level 6
         Bit 5: level 5
         Bit 4: level 4
         Bit 3: level 3
         Bit 2: level 2
         Bit 1: level 1
         Bit 0: level 0

8) ISRA: Bit vector that indicates active interrupts.
         See MFP interrupts above for equivalent IPL level
         mappings.
         ($FFFA0F)

         Bit 7: level 15
         Bit 6: level 14
         Bit 5: level 13
         Bit 4: level 12
         Bit 3: level 11
         Bit 2: level 10
         Bit 1: level 9
         Bit 0: level 8

9) ISRB: Bit vector that indicates active interrupts.
         See MFP interrupts...
         ($FFFA11)

         Bit 7: level 7
         Bit 6: level 6
         Bit 5: level 5
         Bit 4: level 4
         Bit 3: level 3
         Bit 2: level 2
         Bit 1: level 1
         Bit 0: level 0


10) IMRA: Bit vector in which we must indicate (with a 1), the IPL level
            we are using. (bit nr° 5 = IPL 13 if we are using TIMER A, etc...)
            ($FFFA13)

           Bit 7: level 15
           Bit 6: level 14
           Bit 5: level 13
           Bit 4: level 12
           Bit 3: level 11
           Bit 2: level 10
           Bit 1: level 9
           Bit 0: level 8

11) IMRB: Bit vector in which we must indicate (with a 1), the IPL level
            we are using. (bit nr° 5 = IPL 5 if we are using TIMER C, etc...)
            ($FFFA15)

           Bit 7: level 7
           Bit 6: level 6
           Bit 5: level 5
           Bit 4: level 4
           Bit 3: level 3
           Bit 2: level 2
           Bit 1: level 1
           Bit 0: level 0

12) VR  : Bit vector:

           . Bit nr° 3 allows obtaining the AUTOMATIC END OF INTERRUPT mode
             , in this case (bit nr° 3 set to 1), it will no longer be necessary to modify
             the IPR, ISR, IMR registers (See TIMER programming below, don't panic!)
           . Bits nr° 4 to 7 allow modifying the VECTOR number that will be
             executed
             
             ($FFFA17)

13) TACR: Bit vector that controls TIMER A:
           WARNING, only bits 0 to 3 of the TACR Register are used!!!
           ($FFFA19) 

           Bit Number 
           of the Register    Action on TIMER A and PRESCALER
          
            |76543210|                                         |
            +--------+-----------------------------------------+

             ****0000     Stops TIMER A
             ****0001     DELAY MODE, /4
             ****0010     DELAY MODE, /10
             ****0011     DELAY MODE, /16
             ****0100     DELAY MODE, /50
             ****0101     DELAY MODE, /64
             ****0110     DELAY MODE, /100
             ****0111     DELAY MODE, /200
             ****1000     EVENT COUNT MODE
             ****1001     PULSE MEASUREMENT MODE, /4
             ****1010     PULSE MEASUREMENT MODE, /10
             ****1011     PULSE MEASUREMENT MODE, /16
             ****1100     PULSE MEASUREMENT MODE, /50
             ****1101     PULSE MEASUREMENT MODE, /64
             ****1110     PULSE MEASUREMENT MODE, /100
             ****1111     PULSE MEASUREMENT MODE, /200

   The TACR register allows coding the CALL FREQUENCY of TIMER A.

   EXPLANATIONS:
   -------------

 - The MFP 68901 works with an internal clock of 24.576 MHz.

 - TIMER A is essentially composed of a CONTROL REGISTER and
    a DATA REGISTER.
    ------------------
    The CONTROL REGISTER indicates the TIMER's operating mode,
    which is the TACR register described above.
    By setting the TACR register to the various accepted values (See the table),
    we obtain the different TIMER operating modes:

      The different TIMER A OPERATING MODES are:
      -------------------------------------------
   . DELAY MODE:
     --------------
     The TIMER's DATA REGISTER is decremented at regular intervals
     (at each beat of the internal clock contained in the divisor)
     and when this register becomes 1, an interruption is generated.

     NB: The DATA REGISTER must be a value between 1 and 255.

   Example: TACR=%0011 
   -------
   We are in DELAY MODE (see Table)
   The TACR control register is %11, and the prescaler is 16 
   (Look at the Table)   -------------       ------------------- 
   If we set the data register to 200, for example, our
   interrupt program will be called:   ---------------

   245760/16/200 = 76.8 times per second ...
   -------------
         +-----------------------------------+    
   That is: |MFP FREQUENCY / PRESCALER / DATA|
         +-----------------------------------+

   Another Example: TACR=%0010 (see Table)
   The TACR control register is %10, and the prescaler is 10
   (Look at the Table)  -------------       -------------------       
   If we set the data register to 32, for example, our
   interrupt program will be called:   --------------

   245760/10/32 = 768 times per second ...
   ------------
         +-----------------------------------+    
   That is: |MFP FREQUENCY / PRESCALER / DATA|
         +-----------------------------------+
 
   I will come back to this when we write our first programs...
        

   . EVENT COUNT MODE:
     -----------------    
     It's the same, except here the MFP no longer takes into account
     the prescaler...

   . PULSE WIDTH MEASUREMENT MODE:
     --------------------------------------
     Identical to DELAY MODE, but it can be canceled by an activity
     on the input or output pins of the MFP.

   We will mainly use DELAY MODE...

   Reread carefully what has been said here because it is really very
   important...

                              -----------------

   PIECHOCKI   Laurent
   8, Impasse Bellevue              Continued in the file: INTER_2.DOC
   57980  TENTELING                                        -----------


Back to ASM_Tutorial