812 lines
72 KiB
Plaintext
812 lines
72 KiB
Plaintext
{{
|
||
┌──────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
||
│ Autor: Ingo Kripahle │
|
||
│ Copyright (c) 2010 Ingo Kripahle │
|
||
│ See end of file for terms of use. │
|
||
│ Die Nutzungsbedingungen befinden sich am Ende der Datei │
|
||
└──────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
||
|
||
Informationen : hive-project.de
|
||
Kontakt : drohne235@googlemail.com
|
||
System : TriOS
|
||
Name : [I]nput-[O]utput-[S]ystem - System-API
|
||
Chip : Regnatix
|
||
Typ : Objekt
|
||
Version : 01
|
||
Subversion : 1
|
||
Funktion : System-API - Schnittstelle der Anwendungen zu allen Systemfunktionen
|
||
|
||
Regnatix
|
||
system : Systemübergreifende Routinen
|
||
loader : Routinen um BIN-Dateien zu laden
|
||
eram : Zugriff auf externen RAM
|
||
bus : Kommunikation zu Administra und Bellatrix
|
||
|
||
Administra
|
||
sd-card : FAT16 Dateisystem auf SD-Card
|
||
scr : Screeninterface
|
||
hss : Hydra-Soundsystem
|
||
sfx : Sound-FX
|
||
|
||
Bellatrix
|
||
key : Keyboardroutinen
|
||
screen : Bildschirmsteuerung
|
||
|
||
Komponenten : -
|
||
COG's : -
|
||
Logbuch :
|
||
|
||
13-03-2009-dr235 - string für parameterübergabe zwischen programmen im eram eingerichtet
|
||
19-11-2008-dr235 - erste version aus dem ispin-projekt extrahiert
|
||
|
||
Kommandoliste :
|
||
Notizen :
|
||
|
||
--------------------------------------------------------------------------------------------------------- }}
|
||
|
||
CON
|
||
|
||
'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ür administra und bellatrix
|
||
#23, REG_AL 'strobesignal fü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öße des inputbuffers
|
||
ERAM = 1024 * 512 * 2 'größe eram
|
||
HRAM = 1024 * 32 'größ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 öffnen
|
||
SCR_FILL 'screenpuffer mit zeichen fü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
|
||
|
||
#150, SDW_START 'wav direkt von sdcard abspielen
|
||
SDW_STOP
|
||
SDW_STATUS
|
||
|
||
'interface zum hss-player
|
||
#0, iEndFlag 'Repeat oder Ende wurde erreicht
|
||
iRowFlag 'Flag das Songzeile fertig ist
|
||
iEngineC 'Patternzähler
|
||
iBeatC 'Beatzähler
|
||
iRepeat 'zähler für loops
|
||
#5, iChannel
|
||
#5, iChannel1
|
||
#10, iChannel2
|
||
#15, iChannel3
|
||
#20, iChannel4
|
||
#0, iNote
|
||
iOktave
|
||
iVolume
|
||
iEffekt
|
||
iInstrument
|
||
|
||
'globale funktionen
|
||
GLOB_VER = 98 'codeversion abfragen
|
||
GLOB_RESET = 99 'reset auslösen
|
||
|
||
VAR
|
||
long lflagadr 'adresse des loaderflag
|
||
byte dname[16] 'puffer für dateiname
|
||
byte parapos 'position im parameterstring
|
||
byte cog[8]
|
||
byte cogs
|
||
|
||
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 überträgt und startet, bekommen alle Props
|
||
ein reset, wodurch bellatrix auf einen treiber wartet. für testzwecke erledigt diese routine den upload des
|
||
standard-vga-treibers. wird aus dem programm später eine bin-datei generiert, welche über den loader gestartet wird
|
||
sollte diese routine auskommentiert werden.}}
|
||
|
||
waitcnt(cnt + 50_000_000) 'warte auf administra
|
||
sdmount 'sd-karte mounten
|
||
bload(string("vid.bin")) 'vga-treiber zu bellatrix ü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öschen
|
||
{{paradel - system: parameterbereich löschen}}
|
||
|
||
repeat i from 0 to 63
|
||
ram_write(0,PARAM+i)
|
||
|
||
PUB paranext(stradr): err | i,c 'system: überträgt den nächsten parameter in stringdatei
|
||
{{paranext(stradr) - system: überträgt den nächsten parameter in stringdatei
|
||
rückgabewert 0 --> kein weiterer parameter
|
||
>0 --> parameter gültig}}
|
||
|
||
if ram_read(PARAM+parapos) <> 0 'stringende?
|
||
repeat until ram_read(PARAM+parapos) > CHAR_SPACE 'führende leerzeichen ausblenden
|
||
parapos++
|
||
|
||
i := 0
|
||
repeat 'nächsten string kopieren
|
||
c := ram_read(PARAM + parapos)
|
||
byte[stradr + i] := c
|
||
parapos++
|
||
i++
|
||
byte[stradr + i] := 0 'string abschließ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 öffnen
|
||
repeat ii from 0 to 15 '16 bytes header --> bellatrix
|
||
n := sdgetc
|
||
bus_putchar2(n)
|
||
sdclose 'bin-datei schießen
|
||
|
||
' objektgröße empfangen
|
||
plen := bus_getchar2 << 8 'hsb empfangen
|
||
plen := plen + bus_getchar2 'lsb empfangen
|
||
|
||
' bin-datei einlesen ------------------------------------------------------
|
||
sdopen("r",stradr) 'bin-datei ö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 getcogs(wert):status 'system: fragt freie cogs der Propellerchips ab
|
||
case wert
|
||
0:
|
||
get_self_cogs 'Regnatix
|
||
status := cogs
|
||
1: 'Administra
|
||
bus_putchar1(80) 'code 80 = freie cogs
|
||
status := bus_getchar1 'statuswert empfangen
|
||
2: 'Bellatrix
|
||
bus_putchar2($0) 'kommandosequenz einleiten
|
||
bus_putchar2($5) 'code 5 = freie cogs
|
||
status := bus_getchar2 'statuswert empfangen
|
||
|
||
PUB get_self_cogs |i,c 'system: fragt freie cogs von regnatix ab
|
||
{{ fragt freie cogs ab }}
|
||
i :=0
|
||
cogs := 0
|
||
repeat 'loads as many cogs as possible and stores their cog numbers
|
||
c := cog[i] := cognew(@entry, 0)
|
||
if c=>0
|
||
i++
|
||
while c => 0
|
||
cogs := i
|
||
repeat 'unloads the cogs and updates the string
|
||
i--
|
||
if i=>0
|
||
cogstop(cog[i])
|
||
while i=>0
|
||
|
||
PUB get_version(wert): version|a,b,c 'system: codeversion der slaves abfragen
|
||
version := 0
|
||
case wert
|
||
1: 'administra
|
||
bus_putchar1(GLOB_VER)
|
||
version := bus_getchar1
|
||
version := (version << 8) + bus_getchar1
|
||
version := (version << 8) + bus_getchar1
|
||
2: 'bellatrix
|
||
bus_putchar2(0) 'kommandosequenz einleiten
|
||
bus_putchar2(GLOB_VER)
|
||
version := bus_getchar2
|
||
version := (version << 8) + bus_getchar2
|
||
version := (version << 8) + bus_getchar2
|
||
return
|
||
|
||
|
||
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 über loader
|
||
{{ldbin - loader: startet bin-datei ü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ß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ßen
|
||
{{sdclose - sd-card: datei schließen}}
|
||
bus_putchar1(SD_CLOSE)
|
||
err := bus_getchar1
|
||
|
||
PUB sdopen(modus,stradr):err | len,i 'sd-card: datei öffnen
|
||
{{sdopen(modus,stradr) - sd-card: datei ö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öffnet
|
||
{{sddir - sd-card: directory wird geöffnet}}
|
||
bus_putchar1(SD_DIROPEN)
|
||
|
||
PUB sdnext: stradr | flag,len,i 'sd-card: nächster dateiname aus verzeichnis
|
||
{{sdnext - sd-card: nächster dateiname aus verzeichnis
|
||
stradr: zeiger auf dateiname oder 0}}
|
||
|
||
bus_putchar1(SD_NEXTFILE) 'kommando: nächsten eintrag holen
|
||
flag := bus_getchar1 'flag empfangen
|
||
len := bus_getchar1 'längenbyte empfangen
|
||
if flag == 0 'ist eintrag gü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öße abfragen
|
||
{{sdfsize: fsize - sd-card: dateigröß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 hss_playfile(stradr) | status 'hss: spielt übergebene hss-datei von sd-card
|
||
status := hss_load(stradr)
|
||
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ä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 wav_play(stradr): status | len,i 'sdw: spielt wav-datei direkt von sd-card
|
||
bus_putchar1(SDW_START)
|
||
len := strsize(stradr)
|
||
bus_putchar1(len)
|
||
repeat i from 0 to len - 1
|
||
bus_putchar1(byte[stradr++])
|
||
status := bus_getchar1
|
||
|
||
PUB wav_stop
|
||
bus_putchar1(SDW_STOP)
|
||
|
||
PUB wav_status: status 'sdw: status des players abfragen
|
||
bus_putchar1(SDW_STATUS)
|
||
status := bus_getchar1
|
||
|
||
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 - 0FFFFF
|
||
outa[15..8] := adresse >> 11 'höherwertige adresse setzen
|
||
outa[23] := 1 'obere adresse in adresslatch ü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öherwertige adresse setzen
|
||
outa[23] := 1 'obere adresse in adresslatch ü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: ü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: übergibt tastaturstatus
|
||
{{keystat:status - key: ü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ückt wird
|
||
{{keywait: n - key: wartet bis eine taste gedrü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ängenbyte)
|
||
{{printcstr(eadr) - screen: bildschirmausgabe einer zeichenkette im eram (mit lä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ä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öschen
|
||
{{printcls - screen: screen lö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ächsten tabulatorposition
|
||
{{printtab - screen: zur nä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öschen, kopfzeile ausgeben und setzen
|
||
{{screeninit(stradr,n) - screen lö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 ü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
|
||
|
||
CON
|
||
'prop 1 - administra (bus_putchar1, bus_getchar1)
|
||
'prop 2 - bellatrix (bus_putchar2, bus_getchar2)
|
||
|
||
PUB bus_putchar1(c) 'bus: byte an prop2 (administra) senden
|
||
{{bus_putchar1(c) - bus: byte senden an prop1 (administra)}}
|
||
outa := %00001000_01011000_00000000_00000000 'prop1=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, prop1=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 'prop1=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 'prop1=1, busclk=0
|
||
|
||
PUB bus_putchar2(c) 'bus: byte an prop1 (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 prop1 (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
|
||
org
|
||
'
|
||
' Entry
|
||
'
|
||
entry jmp entry 'just loops
|
||
|
||
|
||
sderr0 byte " OK ",0
|
||
sderr1 byte " Kein FAT1-Volume! ",0
|
||
sderr2 byte " Falsche Sektorgröße! ",0
|
||
sderr3 byte " Falsche Clustergröße! ",0
|
||
sderr4 byte " Nicht zwei FAT´s! ",0
|
||
sderr5 byte " Falsche FAT-Signatur! ",0
|
||
sderr6 byte " Zu viele Cluster! ",0
|
||
sysbin byte "reg.sys",0
|
||
|
||
{{
|
||
|
||
┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
||
│ TERMS OF USE: MIT License │
|
||
├──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
|
||
│Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation │
|
||
│files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, │
|
||
│modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software│
|
||
│is furnished to do so, subject to the following conditions: │
|
||
│ │
|
||
│The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.│
|
||
│ │
|
||
│THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE │
|
||
│WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR │
|
||
│COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, │
|
||
│ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. │
|
||
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
||
}}
|
||
|
||
|