"IRQ-loader"

------------------( Jaskier/Taquart )-

Czołem towarzysze. Tak jak obiecywaliśmy w naszym magazynie znajdziecie wiele pożytecznych informacji i programów, które mogą się przydać przy tworzeniu własnych programów użytkowych oraz dem. W tym artykule akurat znajduje się coś pożytecznego dla twórców dem.

Proces ładowania, to w demach newralgiczne miejsce. Chciałoby się ten czas wykorzystać, podobnie jak w demach na C64, na jakieś efekty. Niestety standardowa procedura na to nie pozwala. Zajmuje po prostu cały czas procesora, chociaż przez większość czasu oczekuje w pętli na ustawienie się jakiś znaczników.

O tym, że można inaczej, przekonują nas przykłady takich dem jak Overmind. Podczas ładowania pokazują się tam efekty, gdyż cała procedura ładowania realizuje się w przerwaniach IRQ. Podobnie jest w przypadku magazynu Energy. Ponieważ zaś nigdy nie robimy tajemnic z naszych rozwiązań (pod warunkiem, że sami wykorzystaliśmy je już dużo wcześniej), więc postanowiliśmy przedstawić tutaj nasz sposób. Za źródło niech posłuży nam loader użyty w Energy #1 do ładowania intra. Znajduje się on tam w trzech pierwszych sektorach dysku. Wszystkie inne używane przez nas IRQ-loadery są w istocie bardzo podobne do tego. A zatem zaczynamy. Loader przystosowany jest na sektory po 128 bajtów. Plik zaś zapisany jest w sektorach o strukturze DOS-owej (ostatnie 3 bajty sektora nie stanowią danych pliku). Sam plik zaś również ma strukturę DOS-ową. Ponadto, ponieważ nie używamy systemu, więc absolutnie się nim nie przejmujemy wyłączając ROM i używając dolnej części strony zerowej. Ponieważ dysk na którym ten loader miał być nagrany był całkowicie w foramacie DOS-owym, więc musiałem dokonać paru karkołomnych sztuczek, aby loader zmieścił się w tych wyznaczonych 3 sektorach. Zmniejsza to czytelność programu. Trudno.

Autorem IRQ-SIO jest Electron, zaś cołości loadera Jaskier.

* IRQ-SIO Loader

bufor equ $680 -128 bajtów na dane
 odczytane z sektora.

dcb equ 0 -4 bajtowy bufora na dane
wysyłane do stacji dysków. Jest to kolejno:
-bajt identyfikujący urządzenie. Każde
urządzenie: D1,D2,D3,D4,P1,P2,R1 itd. ma
własny kod.
-kod operacji. Dokładnie taki sam jak w
operacjach SIO.
-numer sektora. Młodszy i starszy bajt.

cksum equ 4 -używane do liczenia sumy
kontrolnej zarówno przy wysyłaniu
komendy do stacji, jak i przy odbiorze.

xdone equ 5 -stan loadera:
0 -odczytywane są dane bloku,
1-4 -odczytywany jest nagłówek bloku.

lindex equ 6 -stan przy wysyłaniu komendy
do stacji:
0-3 -wysyłanie tablicy dcb,
4 -wysyłanie sumy kontrolnej,
5 -wywołanie przerwania końca transmisji.

stcnt equ 7 -stan przy odczycie sektora:
$fe -odczytany został pierwszy bajt od
stacji. Jeśli jest to wartość $41, to znaczy,
że stacja prawidłowo odebrała komendę.
$ff -drugi bajt. Jeśli jest to $43, to znaczy,
że sektor na dysku został prawidłowo
odczytany. Przystępujemy do transmisji.
0-127 -dane sektora.
128 -bajt sumy kontrolnej.

adr equ 8 -adres początku bloku.
end equ 10 -adres końca bloku.

 org $500

loader dta b(0),b(3),a(loader),a(4)

start sei
 cld
 jsr del skok do procedury przygotow.
 stację do wysłania komendy
 stx $d40e w X jest 0
 stx $d400
 lda #$fe
 sta $d301

 lda #$52 komenda odczytu sektora
 sta dcb+1
 lda #4 numer pierwszego sektora
 sta dcb+2 odczywywanego pliku
 lda #$28 ustawiamy częstotliwość zegara
 sta $d204
 sta $d208
 stx $d206
 stx dcb+3
 inx najpierw będziemy odczytywać
 stx xdone nagłówek bloku

 lda <irq
 sta $fffe
 lda >irq
 sta $ffff
 jsr set rozpoczęcie wysyłania komendy
 cli
 bne * a tu każdy może wsadzić nawet
 wektorówkę (jeśli potrafi)
 P.S. ten rozkaz BNE oznacza tyle co JMP

init jmp ($2e2) plik może mieć inity

del lda #$34 informujemy stację, że coś do
 sta $d303 niej będziemy wysyłać
 ldx #0 ustawienie licznika wysyłanych
 stx lindex bajtów
 inx czekamy trochę, aż stacja
 bne *-1 przetrawi fakt, że coś od
 rts niej chcemy. Niestety nie
 można skrócić tej pętli, gdyż niektóre
 stacje są bardzo powolne np.Tygrys Turbo

set lda #$23 ustawiamy POKEY-a do
 sta $d20f transmisji (zapisu)
 lda #$10 przerwanie zapisu
 sta $d20e
 lda #$31 wysyłamy pierwszy bajt do
 sta $d20d stacji
 sta cksum zliczamy sume kontrolną
rts rts

* przerwanie zapisu danych *

irq2 cmp #$20 czy to aby na pewno do mnie?
 bne irq3 do przerwania końca transmisji
 lsr @ ustawiamy na nowo przerwanie
 sta $d20e do zapisu
 inc lindex
 ldx lindex
 cpx #4 czy nadal wysyłamy komendę?
 bcs oi1
 lda dcb,x
 sta $d20d wysyłamy komendę
 clc zliczamy sumę
 adc cksum
 adc #0
 sta cksum
 bcc irqend kończymy przerwanie (bcc=jmp)
oi1 bne oi2
 lda cksum wysyłamy sumę kontrolną
 sta $d20d
irqend pla kończymy przerwanie
 tax
 pla
 rti
oi2 lsr @ ustawiamy przerwanie końca
 sta $d20e transmisji
 bne irqend (bne=jmp)

* przerwanie końca transmisji *

irq3 lda #$13 ustawiamy POKEY-a do
 sta $d20f transmisji (odczytu)
 sta $d20a to nie jest ustawianie
 generatora liczb losowych :-)
 W trybie zapisu ten rejestr pełni funkcję
 resetu złącza szeregowego. Jesli nasąpił
 błąd transmisji to musimy złącze resetować,
 a skoro tak, to dlaczego nie robić tego
 po prostu zawsze? P.S. wsadzana wartość
nie ma znaczenia (podobnie jak przy $d01e).
 lda #$20 przerwanie odczytu
 sta $d20e
 lda #$3c informujemy stację, że coś
 sta $d303 będziemy od niej odbierać
 lda #$fe zerowanie licznika
 sta stcnt odbieranych bajtów
 lda #0 i sumy kontrolnej
 sta cksum
 beq irqend (beq=jmp)

* główne przerwanie *

irq pha
 txa
 pha
 ldx #0
 lda $d20e sprawdzamy jakie nastąpiło
 przerwanie (bity przy odbiorze są
 negacją tych wsadzanych do tej komórki)
 stx $d20e zerowanie rejestru, aby mógł
 wskazywać kolejne przerwania
 and #$30
 cmp #$10
 bne irq2

* przerwanie odczytu *

 asl @ ustawiamy na nowo przerwanie
 sta $d20e
 lda $d20f pobieramy status błędu
 sta $d20a kasujemy status błędu
 bpl error skasowany bit najwyższy i 6-ty
 and #$20 informują, że nastąpił błąd
 beq error
 ldx stcnt czy pobieramy teraz dane
 bmi getsum sektora? (X=0-127)
 lda $d20d pobieramy bajt
 sta bufor,x i do bufora
 clc zliczmy sumę kontrolną
 adc cksum
 adc #0
 sta cksum
 inc stcnt powiększamy ilość
 pla odczytanych bajtów
 tax
 pla
 rti
getsum cpx #$80 czy przesyłana jest
 beq ii1 suma kontrolna?
 inc stcnt jak nie, to powiększ ilość
 lda $d20d przeczytanych bajtów i
 cmp #$41 sprawdź, czy bajt statusu
 beq endirq wysłanego przez stację
 cmp #$43 wskazuje, że wszystko O.K.
 beq endirq
error jsr del jeśli nastąpił błąd, to
 jsr set odczytaj sektor jeszcze raz
endirq pla koniec przerwania
 tax
 pla
 rti
ii1 lda $d20d sprawdzamy sumę kontrolną
 sbc cksum jeśli wszystko O.K., to dane
 bne error z bufora przepisujemy

* loader właściwy *

 tax zerujemy licznik odebranych bajtów
 stx lindex
 lda bufor+$7e który następny
 sta dcb+2 sektor odczytać?
 lda bufor+$7d
 and #3
 sta dcb+3
 ora dcb+2 jeśli zerowy, to znak, że to
 beq l7 koniec pliku
 lda #$34 jeśli jednak będziemy jeszcze
 sta $d303 odczytywać dane, to
 przygotowywujemy stację na zapis komendy
 (czas trwania przepisywania danych będzię
 tą pętlą służącą wyczekaniu, aż stacja
 załapie o co chodzi).
l7 sta l8+1 l8+1 to bajt, który mówi nam
 czy będziemy jeszcze odczytywać sektory
 tya zachowujemy dodatkowo Y
 pha
l1 lda bufor,x
 ldy xdone jaki jest stan loadera
 beq l2 0=odczytujemy dane
 sta adr-1,y nie zero? to znak, że jest
 to adres bloku
 lda <rts po każdym bloku jest robiony
 sta $2e2 jmp ($2e2). Jeżeli żaden
 lda >rts adres nie był tam ustawiony
 sta $2e3 to procesor napotka RTS
 inc xdone zwiększ stan loadera
 cpy #2 czy przesłany został cały
 bne l4 adres początku bloku?
 lda adr sprawdź, czy nie wynosi on
 and adr+1 $ffff, jeśli tak, to znaczy, że
 eor #$ff jest to tylko informacja, że
 bne l3 ten pli jest binarny
 lda #1 przeczytaj adres jeszcze raz
 bne l6 (bne=jmp)
l4 tya
 sec
 sbc #4 sprawdź, czy przeczytany już
 bne l3 został cały nagłówek
l6 sta xdone jeśli tak, to odczytujemy
 jmp l3 dane bloku

l2 sta (adr),y umieszczamy bajt
 lda adr sprawdzamy, czy to już
 cmp end cały blok
 lda adr+1
 sbc end+1
 bcc l5
 inc xdone jeśli tak, to przystępujemy
 na nowo do czytania nagłówka
 stx cksum X może nam się przydać
 jsr init po przeczytaniu całego bloku
robimy skok po $2e2. Standardowo ustawia-
 ny jest tam skok pod rozkaz RTS.
 ldx cksum bierzemy X z powrotem
l5 inc adr następny bajt wsadzimy w
 bne l3 następną komórkę
 inc adr+1
l3 inx
 cpx bufor+$7f sprawdzamy, czy tylko
 tyle bajtów w tym sektorze należy do pliku
 bcc l1 jeśli nie, to odczytujemy następny
 pla pobieramy Y z powrotem
 tay
l8 lda #10 jeśli to był ostatni sektor
 pliku, to tutaj jest #0
 beq *+5 a wówczas...
 jmp error+3 odczyt następnego sektora
 jmp ($2e0) uruchamiamy program

 end

No i tak to wygląda. Może na początku jest to nieco skomplikowane, ale po bliższym przyjrzeniu się, każdy powienien wszystko zrozumieć. Aby było łatwiej, wyjaśnie może dokładniej procedure odczytu i zapisu:

Proces zapisu bajtu do stacji polega na tym, że bajt wysyłany wsadzamy do komórki $d20d, a przerwanie zapisu następuje PO wysłaniu tego bajtu do stacji. Tak więc pierwszy bajt wsadzamy poza przerwaniem, drugi w przerwaniu informującym, że pierwszy bajt został wysłany itd. W przerwaniu informującym, że wysłana została suma kontrolna (która zawsze jest wysyłana na końcu wysyłanego bloku danych) ustawiamy jako następne przerwanie zakończenia transmisji (w domyśle zapisu, gdyż tylko wtedy to przerwanie jest wykorzystywane).

Proces odczytu jest trochę prostszy. Przerwanie odczytu wywoływane jest tutaj zawsze po odczytaniu bajtu ze stacji. W przerwaniu właśnie ten bajt odczytujemy z komórki $d20d. Po odczytaniu wszystkich bajtów odczytujemy sumę kontrolną. Należy przy tym uważać gdyż bajty statusu stacji, wysyłane przez nią dla potwierdzenia, że dostała i zrozumiała komendę, nie są do sumy kontrolnej wliczane.

A teraz po kolei w punktach proces odczytu sektora:

1) Wysłanie 4 bajtów komendy + suma.

2) Natychmiast po tym, stacja wysyła nam bajt $41, który informuje nas, że stacja zrozumiała komendę.

3) Teraz następuje chwila przerwy. Stacja musi zakręcić dyskiem i odczytać sektor.

4) Jeśli sektor na dysku był prawidłowy, stacja wysyła nam bajt $43 który informuje nas, że wszytsko O.K. i zaraz nam wyśle dane.

5) Odbieramy 128+1 (256+1 lub 512+1 -zależnie gęstości dyskietki) bajtów danych sektora z sumą kontrolną.

6) Koniec transmisji sektora.

A teraz dla aktywnych zapis:

1) 4+1 bajtów -komenda + suma.

2) Natychmiast po tym stacja wysyła nam $41, że zrozumiała komende.

3) Wysyłamy 128+1 (256+1 lub 512+1 -zależnie od gęstości dyskietki) bajtów danych sektora z sumą kontrolną. Ponieważ stacja jest przygotowana na to, nie musimy dawać takiej długiej pętli po umieszczeniu #$34 w komórce $d303.

4) Teraz następuje chwila przerwy. Stacja zakręci dyskiem i zapisze sektor.

5) Odbieramy bajt $43, który oznacza, że sektor został prawidłowo odebrany i zapisany.

6) Koniec transmisji.

I co? Nadal jest to takie trudne?

Jak zapewne zauważyliście w Energy #1 jest więcej niż jeden IRQ-loader. Drugi uruchamiany jest po intrze podczas ładowania całego magazynu. Jego cechą charakterystyczną jest to, że oprócz muzyczki na dwóch kanałach, odgrywane są tam na dwóch kanałach sample. Wbrew pozorom jest to bardzo prymitywny efekt. Zauważcie bowiem, że do operacji zapisu-odczytu używane są faktycznie generatory 3 i 4 POKEY-a, ale tylko i wyłącznie dla ustalenia częstotliwości transmisji. Ich głośność do tego nic nie wnosi, a tylko tyle potrzeba, aby sample mogły grać. Ddatkowo mamy jeszcze jedno ułatwienie. Po wsadzeniu wartośc $34 do komórki $d303 nie musimy robić takiej długiej pętli oczekując na to, aż stacja załapie, że chcemy do niej coś wysłać. Po prostu w tym czasie wywołujemy player. Drobne problemy nastręczyć może procedura odgrywania sampli. Nie możemy jej przerywać na nazbyt długo, bo sample zaczną źle brzmieć, a procedura przepisująca bufor do pamięci trwa naprawdę sporo. Rozwiązanie jest proste. Ta procedura nie znajdować się będzie w przerwaniu, ale w normalnym programie, do którego skaczemy po ustawieniu się znacznika, że cały sektor został przeczytany, a w jej środek wsadzamy drugą procedurę odgrywania sampli. Całość działa w sposób następujący. Przepisanie jednego bajtu z bufora, odegranie sampla, przepisanie bajtu z bufora, odegranie sampla itd.

Trzecim typem loadera użytym w Energy #1 jest loader ładujący artykuły. Wbrew pozorom nie jest on identyczny z loaderem przedstawionym w tym artykule. Ktoś spostrzegawczy zauważył zapewne, że podczas działania tego loadera na ekranie znajduje się logos w pięciu kolorach. A skoro tych kolorów jest pięć, to znaczy, że jest na fontach. A skoro ten logos jest duży, to znaczy, że są 2 generatory znaków. A skoro są 2 generatory, to znaczy, że gdzieś w środku jest przerwanie NMI. A skoro jest przerwanie NMI, to nie może być przerwań IRQ, gdyż mają one tę właściwość, że mogą opóźnić odebranie NMI. A zatem całość musi być poza przerwaniami IRQ. Niby niemożliwe, ale zauważmy, że tak naprawdę, to przerwania potrzebne są nam tylko do tego, aby dowiedzieć się kiedy odebrać następny bajt ze stacji, albo go do niej wysłać. Tego zaś możemy dowiedzieć się z komórki $d20e. Bity w niej są bowiem kasowane właśnie przy wystąpieniu danego przerwania. Loader jest dość podobny do tego przedstawionego tutaj. Różnice polegają na tym, że nie ma rozkazu CLI, a procedury w przerwaniach są przeniesione do głównego programu i dodana jest procedurka śledząca komórke $d20e i w zależności od niej skacząca do odpowiednich procedur.

I to by było na tyle, jeśli chodzi o własne procedury obsługi stacji. W następnym numerze postaramy się rozszerzyć ten temat o procedury obsługi w różnych systemach turbo oraz (jeśli uda nam się namówić na to Foxa) procedury dla stacji Karin.

Jaskier/Taquart