Eredetileg az ezt követő részek már nem lettek volna bennt ebben a doksiban, de akad egy-két dolog, amiről nem ártana egy kicsit többet beszélni.
Kezdjük mondjuk a 1Ch-s interrupttal:

Az alaplapon található egy többcsatornás időzítő, mely az INTEL 8253 programozható számláló-időzítő áramkörre épül, ma már inkább 8254-es továbbfejlesztett számlálót vagy kompatibilis áramkört alkalmaznak. Ez a számláló alapesetben 18.2-szer hívja meg az 'iNT 8h'-t, ami a saját műveletei után az 'iNT 1ch-t' hívja meg. Azonban azt is meg ehet adni, hogy másodpercenként hányszor hívódjon meg. A legkisebb érték 18.2, ekkor másodpercenként 18.2-szer hívódik meg a 1Ch-s megszakítás.

Ebből következik, hogy : 1,193,180/irqZ = speed, ahol az irqZ a másodpercenkénti megszakítások számát jelenti, a speed pedig a hozzá tartozó számlálási állandót. A kis procedure:

      setspeed:  cli                  mov     dx, 43h                  mov     al, 36h                  out     dx, al                  mov     dx, 40h                  mov     ax, Speed                  shr     ax,10                  out     dx, al                  shr     ax, 8                  out     dx, al                  sti                  ret
A cli utasítás a clear interruptot jelenti, azaz addig nem kap a proci egyetlen interrupt hívást sem, míg nem engedélyeztük az sti utaítással. OUT-tal egy portra lehet kiirni egy számot, míg in-nel be lehet olvasni a portról. az első paraméter azt mutatja, hogy melyik portra szeretnénk írni/olvasni, a második azt, hogy mit írjunk ki/mibe olvassunk be.

Ez eddig nagyon jó, de mire is lehet használni ? - teheted fel a kérdést. A válasz egyszerű: memóriarezidens programok írására . Képzeld csak el: ha sikerülne ezt az interruptot átírni úgy, hogy a saját programunk hajtódjon végre, akkor kész is lenne a memóriarezidens (Terminate and Stay Resident) programunk. Akkor hát ne csak beszéljünk az ötletekről, hanem valósítsuk is meg azokat. Még egy figyelmeztetés: az olyan rezidens programoknál , melyek az 1Ch interruptot magukra állítják az a fontos, hogy minél gyorsabb és minél kisebb legyen a program, hiszen gondolj csak bele, mi történne, ha az interrupt újraindulna, de a program még tovább akarna futni...

Ennyi rizsázás után bele is kezdhetnénk. Két fontos interrupt hívás fontos számunkra:

  SET INTERRUPT VECTOR   Be: AH      25h       AL      Interrupt száma       DS:DX   Az új interrupt címe       iNT     21h   GET INTERRUPT VECTOR   Be: AH      35h       AL      Interrupt száma       iNT     21h
Ezekkel tudjuk lekérdezni és felülírni a régi interruptokat. Akkor már "csak" egy új rezidens részt kell írni, melynek a végén egy iret lesz, mivel interrupt return... Csak nem szabad elfeledkezni, hogy a régi interrupt is csinálhatott valamit, ezért meg is kellene hívni a régi interruptot a az új interrupt végén. Most csinálunk egy kis trükköt:
      theoldint:   pushf                    db 9ah            ;CALL FAR        oldint:     dw 0,0                    ret
Ezzel az ügyes kis trükkel megoldható, hogy a régi interruptot is meg tudjuk hívni. Az oldint címre kell beírni a régi interrupt címét offset/szegmens alakban. A programunk rezidenssé tételét az INT 27h oldja meg, ahol dx-be kell a rezidens programrészlet méretét+még egy kicsit rakni ... :) Most már csak egy példaprogram szükséges a teljes megértéshez !
  -------------------------[ TSR EXAMPLE ]-----------------------   org      100h   section  .text   start:                jmp     rulez   newproc:                                    ; Ez lesz az új int                push    es                     ; felhasznált regiszterek                push    di                     ; elmentése                push    si                push    ax                push    word 0b800h            ; es=0b800h                pop     es                xor     di,di                mov     ah,7                   ; 7-es színnel                mov     si,abrak               ; si=abrak+point                add     si,[point]                mov     al,BYTE [cs:si]        ; al=cs:[si]                mov     [es:di],ax             ; kiirjuk                inc     byte [point]           ; növeljük a mutatót                mov     ax,[point]                cmp     ax,4                   ; ha az négy, akkor                jne     dance                xor     ax,ax                  ; kinullázzuk                mov     [point],ax    dance:      jmp     new_end                point   dw 0                abrak   db '|/-\'    new_end:    pop     ax                     ; felhasznált regiszterek                pop     si                     ; visszaállítása                pop     di                pop     es                call    oldintp                ; a régi int meghívása                iret    oldintp:                ; Ez a régi interrupt                    pushf                    db 9ah    oldint:         dw 0,0                    ret    sizeofint equ $-newproc                    ; ez a hossz   rulez: push    cs          pop     ds          mov     ah,35h                       ; régi cím elmentése          mov     al,1ch          int     21h          mov     [cs:oldint],bx          mov     [cs:oldint+2],es          mov     ah,25h                       ; új beírása          mov     al,1ch          mov     dx,newproc          int     21h          mov     dx,sizeofint+0ffeh          int     27h                          ; rezidenssé válunk   section  .data   section .bss    -------------------------[ END OF TSR  ]-----------------------
Na persze, hogy megint van valami újdonság, mégpedig a $ jel. Ez az aktuális címre mutat. Ugrásokat úgy is meg lehet valósítani, hogy tudjuk, hova kell ugrani, kiszámoljuk, hogy ez hány byte, és jmp $+ennyi_byte