TriOS-alt/system/bellatrix/vectron-1-vecdem1/ios.spin

762 lines
66 KiB
Plaintext
Raw Normal View History

2010-11-26 23:58:06 +01:00
<EFBFBD><EFBFBD>{{ ---------------------------------------------------------------------------------------------------------
Hive-Computer-Projekt
Name : IOS
Chip : Regnatix-Code (IO-Kernroutinen)
Version : 0.1
Dateien : ios.spin
Beschreibung : Anwendungsbibliothek
Eigenschaften :
system : system<00>bergreifende routinen
loader : routinen um bin-dateien zu laden
sd-card : FAT16 Dateisystem auf SD-Card
scr : Screeninterface
hss : Hydra-Soundsystem
sfx : Sound-FX
eram : Zugriff auf externen RAM
key : Keyboardroutinen
screen : Bildschirmsteuerung
bus : Kommunikation zu Administra und Bellatrix
Logbuch :
13.03.2009 - string f<00>r parameter<00>bergabe zwischen programmen im eram eingerichtet
19.11.2008 - erste version aus dem ispin-projekt extrahiert
Kommandoliste:
--------------------------------------------------------------------------------------------------------- }}
CON
_CLKMODE = XTAL1 + PLL16X
_XINFREQ = 5_000_000
'signaldefinition regnatix
#0, D0,D1,D2,D3,D4,D5,D6,D7 'datenbus
#8, A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10 'adressbus
#19, REG_RAM1,REG_RAM2 'selektionssignale rambank 1 und 2
#21, REG_PROP1,REG_PROP2 'selektionssignale f<00>r administra und bellatrix
#23, REG_AL 'strobesignal f<00>r adresslatch
#24, HBEAT 'front-led
BUSCLK 'bustakt
BUS_WR '/wr - schreibsignal
BUS_HS ' '/hs - quittungssignal
'zeichencodes
CHAR_RETURN = $0D 'eingabezeichen
CHAR_NL = $0D 'newline
CHAR_SPACE = $20 'leerzeichen
CHAR_BS = $C8 'tastaturcode backspace
CHAR_TER_BS = $102 'terminalcode backspace
KEY_CTRL = $02
KEY_ALT = $04
KEY_OS = $08
'systemvariablen
LOADERPTR = $0FFFFB '1 Byte 'eram-adresse mit pointer auf loader-register
MAGIC = $0FFFFA '1 Byte 'Warmstartflag
SIFLAG = $0FFFF9 '1 byte 'screeninit-flag
BELDRIVE = $0FFFED '12 Byte 'Dateiname aktueller Grafiktreiber
PARAM = $0FFFAD '64 Byte 'Parameterstring
SYSVAR = $0FFFAC 'Adresse des obersten freien Bytes
CNT_HBEAT = 5_000_0000 'blinkgeschw. front-led
DB_IN = %00000111_11111111_11111111_00000000 'maske: dbus-eingabe
DB_OUT = %00000111_11111111_11111111_11111111 'maske: dbus-ausgabe
OS_TIBLEN = 64 'gr<00><00>e des inputbuffers
ERAM = 1024 * 512 * 2 'gr<00><00>e eram
HRAM = 1024 * 32 'gr<00><00>e hram
RMON_ZEILEN = 16 'speichermonitor - angezeigte zeilen
RMON_BYTES = 8 'speichermonitor - zeichen pro byte
'sdcard-funktionen
#0, OPT
SD_MOUNT
SD_DIROPEN
SD_NEXTFILE
SD_OPEN
SD_CLOSE
SD_GETC
SD_PUTC
SD_READ
SD_WRITE
SD_EOF
SD_SEEK
SD_FATTRIB
SD_FTIME
SD_FSIZE
'screeninterface
#50, SCR_OPEN 'containerdatei <00>ffnen
SCR_FILL 'screenpuffer mit zeichen f<00>llen
SCR_READ 'screen in den puffer laden
SCR_WRITE 'screen auf disk schreiben
SCR_GETNR 'nummer des aktuellen screens abfragen
SCR_SETPOS 'zeiger auf position im puffer setzen
SCR_GETPOS 'aktuelle position im puffer abfragen
SCR_GETC 'zeichen wird aus dem puffer gelesen
SCR_PUTC 'zeichen wird in den puffer geschrieben
SCR_FLUSH 'aktuellen puffer auf disk schreiben
SCR_ERR 'fehlerstatus abfragen
SCR_MAXSCR 'anzahl screens des containers abfragen
'hss-funktionen
#100, CHSS_LOAD
CHSS_PLAY
CHSS_STOP
CHSS_PAUSE
CHSS_PEEK
CHSS_INTREG
CHSS_VOL
CSFX_FIRE
CSFX_SETSLOT
'interface zum hss-player
#0, iEndFlag 'Repeat oder Ende wurde erreicht
iRowFlag 'Flag das Songzeile fertig ist
iEngineC 'Patternz<00>hler
iBeatC 'Beatz<00>hler
iRepeat 'z<00>hler f<00>r loops
#5, iChannel
#5, iChannel1
#10, iChannel2
#15, iChannel3
#20, iChannel4
#0, iNote
iOktave
iVolume
iEffekt
iInstrument
VAR
long lflagadr 'adresse des loaderflag
byte dname[16] 'puffer f<00>r dateiname
byte parapos 'position im parameterstring
PUB start: wflag | n 'system: initialisiert system
{{start - initialisiert das grundsystem
wflag == 1 --> warmstart}}
bus_init 'bus initialisieren
lflagadr := rd_long(LOADERPTR) 'adresse der loader-register setzen
n := ram_read(MAGIC)
if n <> 235
ram_write(235,MAGIC) 'warmstartflag
return 0
elseif n == 235
return 1
PUB startram 'system: initialisierung des systems bei ram-upload
{{startram - wenn man zu testzwecken das programm direkt in den ram <00>bertr<00>gt und startet, bekommen alle Props
ein reset, wodurch bellatrix auf einen treiber wartet. f<00>r testzwecke erledigt diese routine den upload des
standard-vga-treibers. wird aus dem programm sp<00>ter eine bin-datei generiert, welche <00>ber den loader gestartet wird
sollte diese routine auskommentiert werden.}}
waitcnt(cnt + 50_000_000) 'warte auf administra
sdmount 'sd-karte mounten
bload(string("vga.bin")) 'vga-treiber zu bellatrix <00>bertragen
waitcnt(cnt + 50_000_000) 'warte bis treiber initialisiert ist
PUB paraset(stradr) | i,c 'system: parameterbereich beschreiben
{{paraset(stradr) - system: ein 0-term-string wird von stradr in den parameterbereich kopiert}}
paradel
repeat i from 0 to 63 ' puffer ist mx. 64 zeichen lang
c := byte[stradr+i]
ram_write(c,PARAM+i)
if c == 0 'bei stringende vorzeitig beenden
return
PUB parastart 'system: setzt den zeiger auf parameteranfangsposition
{{parastart - setzt den zeiger auf parameteranfangsposition}}
parapos := 0
PUB paradel | i 'system: parameterbereich l<00>schen
{{paradel - system: parameterbereich l<00>schen}}
repeat i from 0 to 63
ram_write(0,PARAM+i)
PUB paranext(stradr): err | i,c 'system: <00>bertr<00>gt den n<00>chsten parameter in stringdatei
{{paranext(stradr) - system: <00>bertr<00>gt den n<00>chsten parameter in stringdatei
r<00>ckgabewert 0 --> kein weiterer parameter
>0 --> parameter g<00>ltig}}
if ram_read(PARAM+parapos) <> 0 'stringende?
repeat until ram_read(PARAM+parapos) > CHAR_SPACE 'f<00>hrende leerzeichen ausblenden
parapos++
i := 0
repeat 'n<00>chsten string kopieren
c := ram_read(PARAM + parapos)
byte[stradr + i] := c
parapos++
i++
byte[stradr + i] := 0 'string abschlie<00>en
until (c == CHAR_SPACE) or (c == 0)
return 1
else
return 0
PUB bload(stradr) | n,rc,ii,plen 'system: bellatrix mit grafiktreiber initialisieren
{{bload(stradr) - bellatrix mit grafiktreiber initialisieren
stradr - adresse eines 0-term-strings mit dem dateinamen des bellatrixtreibers
}}
' kopf der bin-datei einlesen ------------------------------------------------------
rc := sdopen("r",stradr) 'datei <00>ffnen
repeat ii from 0 to 15 '16 bytes header --> bellatrix
n := sdgetc
bus_putchar2(n)
sdclose 'bin-datei schie<00>en
' objektgr<00><00>e empfangen
plen := bus_getchar2 << 8 'hsb empfangen
plen := plen + bus_getchar2 'lsb empfangen
' bin-datei einlesen ------------------------------------------------------
sdopen("r",stradr) 'bin-datei <00>ffnen
repeat ii from 0 to plen-1 'datei --> bellatrix
n := sdgetc
bus_putchar2(n)
sdclose
PUB breset 'system: bellatrix neu starten
{{breset - bellatrix neu starten}}
bus_putchar2($0) 'kommandosequenz einleiten
bus_putchar2(99) 'code 99 = reboot
PUB stop 'loader: beendet anwendung und startet os
{{stop - beendet anwendung und startet os}}
sdmount
ldbin(@sysbin)
PUB ldsys 'loader: startet sys.bin
{{ldsys - loader: startet sys.bin}}
ldbin(@sysbin)
PUB ldbin(stradr) | len,i,stradr1,stradr2 'loader: startet bin-datei <00>ber loader
{{ldbin - loader: startet bin-datei <00>ber loader}}
len := strsize(stradr)
stradr2 := lflagadr + 1
repeat i from 0 to len - 1 'string in loadervariable kopieren
byte[stradr2][i] := byte[stradr][i]
byte[stradr2][++i] := 0 'string abschlie<00>en
byte[lflagadr][0] := 1 'loader starten
PUB sdmount | err 'sd-card: mounten
{{sdmount - sd-card: mounten}}
bus_putchar1(SD_MOUNT)
err := bus_getchar1
if err > 0
print(string("Status : "))
printdec(err)
print(string(" = "))
case err
1: print(@sderr1)
2: print(@sderr2)
3: print(@sderr3)
4: print(@sderr4)
5: print(@sderr5)
6: print(@sderr6)
printchar(char_nl)
PUB sdclose:err 'sd-card: datei schlie<00>en
{{sdclose - sd-card: datei schlie<00>en}}
bus_putchar1(SD_CLOSE)
err := bus_getchar1
PUB sdopen(modus,stradr):err | len,i 'sd-card: datei <00>ffnen
{{sdopen(modus,stradr) - sd-card: datei <00>ffnen}}
bus_putchar1(SD_OPEN)
bus_putchar1(modus)
len := strsize(stradr)
bus_putchar1(len)
repeat i from 0 to len - 1
bus_putchar1(byte[stradr++])
err := bus_getchar1
PUB sdgetc: char 'sd-card: zeichen aus datei lesen
{{sdgetc: char - sd-card: zeichen aus datei lesen}}
bus_putchar1(SD_GETC)
char := bus_getchar1
PUB sdputc(char) 'sd-card: zeichen in datei schreiben
{{sdputc(char) - sd-card: zeichen in datei schreiben}}
bus_putchar1(SD_PUTC)
bus_putchar1(char)
PUB sddir 'sd-card: verzeichnis wird ge<00>ffnet
{{sddir - sd-card: directory wird ge<00>ffnet}}
bus_putchar1(SD_DIROPEN)
PUB sdnext: stradr | flag,len,i 'sd-card: n<00>chster dateiname aus verzeichnis
{{sdnext - sd-card: n<00>chster dateiname aus verzeichnis
stradr: zeiger auf dateiname oder 0}}
bus_putchar1(SD_NEXTFILE) 'kommando: n<00>chsten eintrag holen
flag := bus_getchar1 'flag empfangen
len := bus_getchar1 'l<00>ngenbyte empfangen
if flag == 0 'ist eintrag g<00>ltig?
repeat i from 0 to len - 1 '20 zeichen dateinamen empfangen
dname[i] := bus_getchar1
dname[i] := 0
return @dname
return 0
PUB sdeof: fl_eof 'sd-card: eof-flag abfragen
{{sdeof: fl_eof - sd-card: eof-flag abfragen}}
bus_putchar1(SD_EOF)
fl_eof := bus_getchar1
return fl_eof
PUB sdseek(wert) 'sd-card: zeiger auf byteposition setzen
{{sdseek(wert) - sd-card: zeiger auf byteposition setzen}}
bus_putchar1(SD_SEEK)
bus_putchar1(wert >> 24) '32bit wert senden hsb/lsb
bus_putchar1(wert >> 16)
bus_putchar1(wert >> 8)
bus_putchar1(wert)
PUB sdfattrib: attrib | wert 'sd-card: dateiattribute abfragen
{{sdfattrib: attrib - sd-card: dateiattribute nach next abfragen}}
bus_putchar1(SD_FATTRIB)
wert := bus_getchar1 ' 1 byte attribute
return
PUB sdftime: ftime | wert 'sd-card: zeitstempel abfragen
{{sdftime: ftime - sd-card: zeitstempel abfragen}}
bus_putchar1(SD_FTIME)
wert := bus_getchar1 << 24 '32 bit empfangen hsb/lsb
wert := wert + bus_getchar1 << 16
wert := wert + bus_getchar1 << 8
wert := wert + bus_getchar1
return wert
PUB sdfsize: fsize | wert 'sd-card: dateigr<00><00>e abfragen
{{sdfsize: fsize - sd-card: dateigr<00><00>e abfragen}}
bus_putchar1(SD_FSIZE)
wert := bus_getchar1 << 24 '32 bit empfangen hsb/lsb
wert := wert + bus_getchar1 << 16
wert := wert + bus_getchar1 << 8
wert := wert + bus_getchar1
return wert
PUB si_open(stradr): err | len,i 'scr: containerdatei <00>ffnen
bus_putchar1(SCR_OPEN)
len := strsize(stradr) 'l<00>ngenbyte senden
bus_putchar1(len)
repeat i from 0 to len - 1 'string senden
bus_putchar1(byte[stradr++])
err := bus_getchar1 'fehlernummer empfangen
PUB si_fill(char) 'scr: screenpuffer mit zeichen f<00>llen
bus_putchar1(SCR_FILL)
bus_putchar1(char)
PUB si_read(snr) 'scr: screen in den puffer laden
bus_putchar1(SCR_READ)
bus_putchar1(snr >> 8) '16 bit screennummer senden hsb/lsb
bus_putchar1(snr)
PUB si_write(snr) 'scr: screen auf disk schreiben
bus_putchar1(SCR_WRITE)
bus_putchar1(snr >> 8) '16 bit screennummer senden hsb/lsb
bus_putchar1(snr)
PUB si_getnr: snr 'scr: nummer des aktuellen screens abfragen
bus_putchar1(SCR_GETNR)
snr := bus_getchar1 << 8 '16 bit screennummer empfangen hsb/lsb
snr += bus_getchar1
PUB si_setpos(pos) 'scr: zeiger auf position im puffer setzen
bus_putchar1(SCR_SETPOS)
bus_putchar1(pos >> 8) '16 bit pufferposition senden hsb/lsb
bus_putchar1(pos)
PUB si_getpos: pos 'scr: aktuelle position im puffer abfragen
bus_putchar1(SCR_GETPOS)
pos := bus_getchar1 << 8 '16 bit position empfangen hsb/lsb
pos += bus_getchar1
PUB si_getc: char 'scr: zeichen wird aus dem puffer gelesen
bus_putchar1(SCR_GETC)
char := bus_getchar1
PUB si_putc(char) 'scr: zeichen wird in den puffer geschrieben
bus_putchar1(SCR_PUTC)
bus_putchar1(char)
PUB si_flush 'scr: aktuellen puffer auf disk schreiben
bus_putchar1(SCR_FLUSH)
PUB si_err: err 'scr: fehlerstatus abfragen
bus_putchar1(SCR_ERR)
err := bus_getchar1
PUB si_maxscr: snr 'scr: anzahl der screens des containers abfragen
bus_putchar1(SCR_MAXSCR)
snr := bus_getchar1 << 8 '16 bit screennummer empfangen hsb/lsb
snr += bus_getchar1
PUB hss_playfile(stradr) | status 'hss: spielt <00>bergebene hss-datei von sd-card
status := hss_load(stradr)
if status > 0
print(string("Status : "))
printdec(status)
printnl
hss_play
PUB hss_stop 'hss: stopt aktuellen song
bus_putchar1(CHSS_STOP)
PUB hss_pause 'hss: pausiert aktuellen song
bus_putchar1(CHSS_PAUSE)
PUB hss_load(stradr): status | len,i 'hss: l<00>dt hss-datei von sd-card in songpuffer
bus_putchar1(CHSS_LOAD)
len := strsize(stradr)
bus_putchar1(len)
repeat i from 0 to len - 1
bus_putchar1(byte[stradr++])
status := bus_getchar1
PUB hss_play 'hss: spielt song im puffer ab
bus_putchar1(CHSS_PLAY)
PUB hss_vol(vol) 'hss: volume einstellen 0..15
bus_putchar1(CHSS_VOL)
bus_putchar1(vol)
PUB hss_peek(n): wert 'hss: registerwert auslesen
bus_putchar1(CHSS_PEEK) 'kommando peek senden
bus_putchar1(n) 'kommando peek senden
wert := bus_getchar1 '32-bit-wert lesen
wert := (wert<<8) + bus_getchar1
wert := (wert<<8) + bus_getchar1
wert := (wert<<8) + bus_getchar1
PUB hss_intreg(n): wert 'hss: interfaceregister auslesen
bus_putchar1(CHSS_INTREG) 'kommando peek senden
bus_putchar1(n) 'kommando peek senden
wert := bus_getchar1 '16-bit-wert lesen
wert := (wert<<8) + bus_getchar1
PUB sfx_setslot(adr,slot) | i,n 'sfx: sendet sfx-daten in sfx-slot
bus_putchar1(CSFX_SETSLOT)
bus_putchar1(slot) 'slotnummer senden
repeat i from 0 to 31 '32 byte sfx-daten senden
n := ram_read(adr + i)
bus_putchar1(n)
PUB sfx_fire(slot,chan) 'sfx: triggert einen bestimmten soundeffekt
bus_putchar1(CSFX_FIRE)
bus_putchar1(slot) 'slotnummer senden
bus_putchar1(chan) 'channel senden
PUB ram_read(adresse):wert 'eram: liest ein byte vom eram
{{ram_read(adresse):wert - eram: ein byte aus externem ram lesen}}
'rambank 1 000000 - 07FFFF
'rambank 2 080000 - 08FFFF
outa[15..8] := adresse >> 11 'h<00>herwertige adresse setzen
outa[23] := 1 'obere adresse in adresslatch <00>bernehmen
outa[23] := 0
outa[18..8] := adresse 'niederwertige adresse setzen
if adresse < $080000 'rambank 1?
outa[reg_ram1] := 0 'ram1 selektieren (wert wird geschrieben)
wert := ina[7..0] 'speicherzelle einlesen
outa[reg_ram1] := 1 'ram1 deselektieren
else
outa[reg_ram2] := 0 'ram2 selektieren (wert wird geschrieben)
wert := ina[7..0] 'speicherzelle einlesen
outa[reg_ram2] := 1 'ram2 deselektieren
PUB ram_write(wert,adresse) 'eram: schreibt ein byte in eram
{{ram_write(wert,adresse) - eram: ein byte in externen ram schreiben}}
'rambank 1 000000 - 07FFFF
'rambank 2 080000 - 08FFFF
outa[bus_wr] := 0 'schreiben aktivieren
dira := db_out 'datenbus --> ausgang
outa[7..0] := wert 'wert --> datenbus
outa[15..8] := adresse >> 11 'h<00>herwertige adresse setzen
outa[23] := 1 'obere adresse in adresslatch <00>bernehmen
outa[23] := 0
outa[18..8] := adresse 'niederwertige adresse setzen
if adresse < $080000 'rambank 1?
outa[reg_ram1] := 0 'ram1 selektieren (wert wird geschrieben)
outa[reg_ram1] := 1 'ram1 deselektieren
else
outa[reg_ram2] := 0 'ram2 selektieren (wert wird geschrieben)
outa[reg_ram2] := 1 'ram2 deselektieren
dira := db_in 'datenbus --> eingang
outa[bus_wr] := 1 'schreiben deaktivieren
PUB rd_long(eadr): wert 'eram: liest long ab eadr
{{rd_long - eram: liest long ab eadr}}
wert := ram_read(eadr)
wert += ram_read(eadr + 1) << 8
wert += ram_read(eadr + 2) << 16
wert += ram_read(eadr + 3) << 24
PUB rd_word(eadr): wert 'eram: liest word ab eadr
{{rd_long(eadr):wert - eram: liest word ab eadr}}
wert := ram_read(eadr)
wert += ram_read(eadr + 1) << 8
PUB wr_long(wert,eadr) | n 'eram: schreibt long ab eadr
{{wr_long(wert,eadr) - eram: schreibt long ab eadr}}
n := wert & $FF
ram_write(n,eadr)
n := (wert >> 8) & $FF
ram_write(n,eadr + 1)
n := (wert >> 16) & $FF
ram_write(n,eadr + 2)
n := (wert >> 24) & $FF
ram_write(n,eadr + 3)
PUB wr_word(wert,eadr) | n 'eram: schreibt word ab eadr
{{wr_word(wert,eadr) - eram: schreibt word ab eadr}}
n := wert & $FF
ram_write(n,eadr)
n := (wert >> 8) & $FF
ram_write(n,eadr + 1)
PUB key:wert 'key: holt tastaturcode
{{key:wert - key: <00>bergibt tastaturwert}}
bus_putchar2($0) 'kommandosequenz einleiten
bus_putchar2($2) 'code 2 = tastenwert holen
wert := bus_getchar2 'tastenwert empfangen
PUB keyspec:wert 'key: statustasten zum letzten tastencode
bus_putchar2($0) 'kommandosequenz einleiten
bus_putchar2($4) 'code 2 = tastenwert holen
wert := bus_getchar2 'wert empfangen
PUB keystat:status 'key: <00>bergibt tastaturstatus
{{keystat:status - key: <00>bergibt tastaturstatus}}
bus_putchar2($0) 'kommandosequenz einleiten
bus_putchar2($1) 'code 1 = tastaturstatus
status := bus_getchar2 'statuswert empfangen
PUB keywait:n 'key: wartet bis taste gedr<00>ckt wird
{{keywait: n - key: wartet bis eine taste gedr<00>ckt wurde}}
repeat
until keystat > 0
return key
PUB input(stradr,anz) | curpos,i,n 'key: stringeingabe
{{input(stradr,anz) - key: stringeingabe}}
curpos := curgetx 'cursorposition merken
i := 0
repeat
n := keywait 'auf taste warten
if n == $0d
quit
if (n == CHAR_BS)&(i>0) 'backspace
printctrl(CHAR_TER_BS)
i--
byte[stradr][i] := 0
elseif i < anz 'normales zeichen
printchar(n)
byte[stradr][i] := n
i++
byte[stradr][i] := 0
PUB print(stringptr) 'screen: bildschirmausgabe einer zeichenkette (0-terminiert)
{{print(stringptr) - screen: bildschirmausgabe einer zeichenkette (0-terminiert)}}
repeat strsize(stringptr)
bus_putchar2(byte[stringptr++])
PUB printcstr(eadr) | i,len 'screen: bildschirmausgabe einer zeichenkette im eram! (mit l<00>ngenbyte)
{{printcstr(eadr) - screen: bildschirmausgabe einer zeichenkette im eram (mit l<00>ngenbyte)}}
len := ram_read(eadr)
repeat i from 1 to len
eadr++
bus_putchar2(ram_read(eadr))
PUB printdec(value) | i 'screen: dezimalen zahlenwert auf bildschirm ausgeben
{{printdec(value) - screen: dezimale bildschirmausgabe zahlenwertes}}
if value < 0 'negativer zahlenwert
-value
printchar("-")
i := 1_000_000_000
repeat 10 'zahl zerlegen
if value => i
printchar(value / i + "0")
value //= i
result~~
elseif result or i == 1
bus_putchar2("0")
i /= 10 'n<00>chste stelle
PUB printhex(value, digits) 'screen: hexadezimalen zahlenwert auf bildschirm ausgeben
{{hex(value,digits) - screen: hexadezimale bildschirmausgabe eines zahlenwertes}}
value <<= (8 - digits) << 2
repeat digits
printchar(lookupz((value <-= 4) & $F : "0".."9", "A".."F"))
PUB printchar(c) 'screen: einzelnes zeichen auf bildschirm ausgeben
{{printchar(c) - screen: bildschirmausgabe eines zeichens}}
bus_putchar2(c)
PUB printctrl(c) 'screen: steuerzeichen ($100 bis $1FF) auf bildschirm ausgeben
{{printctrl(c) - screen: steuerzeichen von $100 bis $1FF wird an terminal gesendet}}
bus_putchar2($0) 'kommandosequenz einleiten
bus_putchar2($3) 'code 3 = sonderzeichen senden
bus_putchar2(c & $0FF) 'unteres byte senden '
PUB printnl 'screen: $0D - CR ausgeben
{{printnl - screen: $0D - CR ausgeben}}
bus_putchar2(CHAR_NL)
PUB printcls 'screen: screen l<00>schen
{{printcls - screen: screen l<00>schen}}
printctrl($00)
PUB curhome 'screen: cursorposition auf erste position setzen
{{curhome - screen: cursorposition auf erste position setzen}}
printctrl($01)
PUB printtab 'screen: zur n<00>chsten tabulatorposition
{{printtab - screen: zur n<00>chsten tabulatorposition}}
printctrl($03)
PUB curchar(char) 'screen: setzt cursorzeichen
{{curchar - screen: setzt cursorzeichen}}
printctrl($04)
bus_putchar2(char)
PUB curpos1 'screen: setzt cursor auf spalte 1 in zeile
{{curpos1 - screen: setzt cursor auf spalte 1 in zeile}}
printctrl($05)
PUB cursetx(x) 'screen: setzt cursorposition auf x
{{cursetx - screen: setzt cursorposition auf x}}
printctrl($06)
bus_putchar2(x)
PUB cursety(y) 'screen: setzt cursorposition auf y
{{cursety - screen: setzt cursorposition auf y}}
printctrl($07)
bus_putchar2(y)
PUB curgetx: x 'screen: abfrage x-position cursor
{{curgetx: x - 'screen: abfrage x-position cursor}}
printctrl($08)
return bus_getchar2
PUB curgety: y 'screen: abfrage y-position cursor
{{curgetx: y - 'screen: abfrage y-position cursor}}
printctrl($09)
return bus_getchar2
PUB setcolor(color) 'screen: farbe setzen
{{setcolor(color) - screen: setzt farbwert}}
printctrl($10)
bus_putchar2(color)
PUB curon 'screen: schaltet cursor an
{{curon - screen: schaltet cursor an}}
printctrl($14)
PUB curoff 'screen: schaltet cursor aus
{{curon - screen: schaltet cursor aus}}
printctrl($15)
PUB sline(n) 'screen: startzeile scrollbereich setzen
{{sline(n) - startzeile scrollbereich setzen}}
printctrl($11)
bus_putchar2(n)
PUB scrollup 'screen: scrollt screen eine zeile hoch
{{scrollup - screen: scrollt screen eine zeile hoch}}
printctrl($16)
PUB scrolldown 'screen: scrollt screen eine zeile runter
{{scrolldown - screen: scrollt screen eine zeile runter}}
printctrl($17)
PUB screeninit(stradr,n) 'screen: l<00>schen, kopfzeile ausgeben und setzen
{{screeninit(stradr,n) - screen l<00>schen, kopfzeile ausgeben und setzen}}
curoff
printctrl($13)
print(stradr)
printnl
sline(n)
curon
curhome
ram_write(0,SIFLAG)
PUB bus_init 'bus: initialisiert bussystem
{{bus_init - bus: initialisierung aller bussignale }}
dira := db_in ' datenbus auf eingabe schalten
outa[18..8] := 0 ' adresse a0..a10 auf 0 setzen
outa[23] := 1 ' obere adresse in adresslatch <00>bernehmen
outa[23] := 0
outa[reg_ram1] := 1 ' ram1 inaktiv
outa[reg_ram2] := 1 ' ram2 inaktiv
outa[reg_prop1] := 1 ' prop1 inaktiv
outa[reg_prop2] := 1 ' prop2 inaktiv
outa[busclk] := 0 ' busclk startwert
outa[bus_wr] := 1 ' schreiben inaktiv
outa[reg_al] := 0 ' strobe aus
PUB bus_putchar1(c) 'bus: byte an prop2 (administra) senden
{{bus_putchar1(c) - bus: byte senden an prop1 (administra)}}
outa := %00001000_01011000_00000000_00000000 'prop2=0, wr=0
dira := db_out 'datenbus auf ausgabe stellen
outa[7..0] := c 'daten --> dbus
outa[busclk] := 1 'busclk=1
waitpeq(%00000000_00000000_00000000_00000000,%00001000_00000000_00000000_00000000,0) 'hs=0?
dira := db_in 'bus freigeben
outa := %00001100_01111000_00000000_00000000 'wr=1, prop2=1, busclk=0
PUB bus_getchar1:wert 'bus: byte vom prop2 (administra) empfangen
{{bus_getchar1:wert - bus: byte empfangen von prop1 (administra)}}
outa := %00000110_01011000_00000000_00000000 'prop2=0, wr=1, busclk=1
waitpeq(%00000000_00000000_00000000_00000000,%00001000_00000000_00000000_00000000,0) 'hs=0?
wert := ina[7..0] 'daten einlesen
outa := %00000100_01111000_00000000_00000000 'prop2=1, busclk=0
PUB bus_putchar2(c) 'bus: byte an prop2 (bellatrix) senden
{{bus_putchar2(c) - bus: byte senden an prop2 (bellatrix)}}
outa := %00001000_00111000_00000000_00000000 'prop2=0, wr=0
dira := db_out 'datenbus auf ausgabe stellen
outa[7..0] := c 'daten --> dbus
outa[busclk] := 1 'busclk=1
waitpeq(%00000000_00000000_00000000_00000000,%00001000_00000000_00000000_00000000,0) 'hs=0?
dira := db_in 'bus freigeben
outa := %00001100_01111000_00000000_00000000 'wr=1, prop2=1, busclk=0
PUB bus_getchar2:wert 'bus: byte vom prop2 (bellatrix) empfangen
{{bus_getchar2:wert - bus: byte empfangen von prop2 (bellatrix)}}
outa := %00000110_00111000_00000000_00000000 'prop2=0, wr=1, busclk=1
waitpeq(%00000000_00000000_00000000_00000000,%00001000_00000000_00000000_00000000,0) 'hs=0?
wert := ina[7..0] 'daten einlesen
outa := %00000100_01111000_00000000_00000000 'prop2=1, busclk=0
DAT
sderr0 byte " OK ",0
sderr1 byte " Kein FAT1-Volume! ",0
sderr2 byte " Falsche Sektorgr<00><00>e! ",0
sderr3 byte " Falsche Clustergr<00><00>e! ",0
sderr4 byte " Nicht zwei FAT<00>s! ",0
sderr5 byte " Falsche FAT-Signatur! ",0
sderr6 byte " Zu viele Cluster! ",0
sysbin byte "sys.bin",0