{{ ┌──────────────────────────────────────────────────────────────────────────────────────────────────────┐ │ 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 ramdisk : Strukturierte Speicherverwaltung: Ramdisk eram : Einfache Speicherverwaltung: Usermem 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 26-03-2010-dr235 - errormeldungen entfernt (mount) 05-08-2010-dr235 - speicherverwaltung für eram eingefügt 18-09-2010-dr235 - fehler in bus_init behoben: erste eram-zelle wurde gelöscht durch falsche initialisierung Kommandoliste : Notizen : --------------------------------------------------------------------------------------------------------- }} CON 'Signaldefinitionen '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 CON 'Zeichencodes 'zeichencodes CHAR_RETURN = $0D 'eingabezeichen CHAR_NL = $0D 'newline CHAR_SPACE = $20 'leerzeichen CHAR_BS = $C8 'tastaturcode backspace CHAR_TER_BS = $102 'terminalcode backspace CHAR_ESC = $1B KEY_CTRL = $02 KEY_ALT = $04 KEY_OS = $08 CON 'Systemvariablen 'systemvariablen LOADERPTR = $0FFFFB '4 Byte 'Zeiger auf Loader-Register im hRAM MAGIC = $0FFFFA '1 Byte 'Warmstartflag SIFLAG = $0FFFF9 '1 byte 'Screeninit-Flag BELDRIVE = $0FFFED '12 Byte 'Dateiname aktueller Grafiktreiber PARAM = $0FFFAD '64 Byte 'Parameterstring RAMDRV = $0FFFAC '1 Byte 'Ramdrive-Flag RAMEND = $0FFFA8 '4 Byte 'Zeiger auf oberstes freies Byte (einfache Speicherverwaltung) RAMBAS = $0FFFA4 '4 Byte 'Zeiger auf unterstes freies Byte (einfache Speicherverwaltung) SYSVAR = $0FFFA3 'Adresse des obersten freien Bytes, darüber folgen Systemvariablen CON 'Sonstiges 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 STRCOUNT = 64 'größe des stringpuffers CON 'ADMINISTRA-FUNKTIONEN -------------------------------------------------------------------------- 'chip-managment #92, AMGR_SETSOUND AMGR_GETSPEC AMGR_SETSYSSOUND AMGR_GETSOUNDSYS AMGR_ALOAD AMGR_GETCOGS AMGR_GETVER AMGR_REBOOT AMGR_DEBUG = 255 'soundeinstellungen #0, SND_HSSOFF SND_HSSON SND_WAVOFF SND_WAVON 'sdcard-funktionen #0, OPT SD_MOUNT SD_DIROPEN SD_NEXTFILE SD_OPEN SD_CLOSE SD_GETC SD_PUTC SD_GETBLK SD_PUTBLK SD_SEEK SD_FATTRIB SD_VOLNAME SD_CHECKMOUNTED SD_CHECKOPEN SD_CHECKUSED SD_CHECKFREE SD_NEWFILE SD_NEWDIR SD_DEL SD_RENAME SD_CHATTRIB SD_CHDIR SD_FORMAT SD_UNMOUNT SD_DMACT SD_DMSET SD_DMGET SD_DMCLR SD_DMPUT SD_EOF 'plexbus-funktionen #31, P_OPEN P_CLOSE P_PUT P_GET P_RESET 'dateiattribute #0, F_SIZE F_CRDAY F_CRMONTH F_CRYEAR F_CRSEC F_CRMIN F_CRHOUR F_ADAY F_AMONTH F_AYEAR F_CDAY F_CMONTH F_CYEAR F_CSEC F_CMIN F_CHOUR F_READONLY F_HIDDEN F_SYSTEM F_DIR F_ARCHIV 'dir-marker #0, DM_ROOT DM_SYSTEM DM_USER DM_A DM_B DM_C 'hss-funktionen #100, CHSS_LOAD CHSS_PLAY CHSS_STOP CHSS_PAUSE CHSS_PEEK CHSS_INTREG CHSS_VOL CSFX_FIRE CSFX_SETSLOT 'wav-funktionen #150, SDW_START 'wav direkt von sdcard abspielen SDW_STOP SDW_STATUS SDW_LVOL SDW_RVOL SDW_PAUSE SDW_POS 'sidcog-funktionen #157, SCOG_MDMPPLAY 'dmp auf sid2 von sdcard abspielen SCOG_SDMPPLAY SCOG_DMPSTOP SCOG_DMPPAUSE SCOG_DMPSTATUS SCOG_DMPPOS SCOG_MUTE SCOG1_setRegister SCOG1_updateRegisters SCOG1_setVolume SCOG1_play SCOG1_noteOn SCOG1_noteOff SCOG1_setFreq SCOG1_setWaveform SCOG1_setPWM SCOG1_setADSR SCOG1_setResonance SCOG1_setCutoff SCOG1_setFilterMask SCOG1_setFilterType SCOG1_enableRingmod SCOG1_enableSynchronization SCOG2_setRegister SCOG2_updateRegisters SCOG2_setVolume SCOG2_play SCOG2_noteOn SCOG2_noteOff SCOG2_setFreq SCOG2_setWaveform SCOG2_setPWM SCOG2_setADSR SCOG2_setResonance SCOG2_setCutoff SCOG2_setFilterMask SCOG2_setFilterType SCOG2_enableRingmod SCOG2_enableSynchronization '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 CON 'BELLATRIX-FUNKTIONEN -------------------------------------------------------------------------- #0, BEL_CMD KEY_STAT KEY_GET PRN_CTRL KEY_FKEY PRN_LOGO #90, BMGR_GETCOLOR BMGR_SETCOLOR BMGR_GETRESX BMGR_GETRESY BMGR_GETCOLS BMGR_GETROWS BMGR_GETCOGS BMGR_GETSPEC BMGR_GETVER BMGR_REBOOT ' +---------- ' | +------- system ' | | +---- version (änderungen) ' | | | +- subversion (hinzufügungen) CHIP_VER = $00_01_01_01 ' ' +---------- ' | +-------- ' | |+------- ' | ||+------ ' | |||+----- ' | ||||+---- ' | |||||+--- ' | ||||||+-- multi ' | |||||||+- loader CHIP_SPEC = %00000000_00000000_00000000_00000001 LIGHTBLUE = 0 YELLOW = 1 RED = 2 GREEN = 3 BLUE_REVERSE = 4 WHITE = 5 RED_INVERSE = 6 MAGENTA = 7 VAR long lflagadr 'adresse des loaderflag long rbas 'einfaches speichermodell: virtuelle startadresse long rend 'einfaches speichermodell: speicherende byte dname[16] 'puffer für dateiname byte strpuffer[STRCOUNT] 'stringpuffer byte parapos 'position im parameterstring OBJ ' debugx : "pterm" 'debug PUB start: wflag | i 'system: ios initialisieren ''funktionsgruppe : system ''funktion : ios initialisieren ''eingabe : - ''ausgabe : wflag - 0: kaltstart '' : 1: warmstart ''busprotokoll : - bus_init 'bus initialisieren 'debugverbindung 'debugx.start(115200) ' Start des Debug-Terminals sddmact(DM_USER) 'wieder in userverzeichnis wechseln lflagadr := ram_rdlong(sysmod,LOADERPTR) 'adresse der loader-register setzen if ram_rdbyte(sysmod,MAGIC) == 235 'warmstart wflag := 1 else 'kaltstart ram_wrbyte(sysmod,235,MAGIC) ram_wrlong(sysmod,SYSVAR,RAMEND) 'Zeiger auf letzte freie Speicherzelle setzen ram_wrlong(sysmod,0,RAMBAS) 'Zeiger auf erste freie Speicherzelle setzen wflag := 0 ram_wrbyte(sysmod,0,RAMDRV) 'Ramdrive ist abgeschaltet rbas := ram_rdlong(sysmod,RAMBAS) rend := ram_rdlong(sysmod,RAMEND) i := BELDRIVE repeat 12 ram_wrbyte(sysmod,0,i++) PUB startram 'system: initialisierung des systems bei ram-upload ''funktionsgruppe : system ''funktion : ios initialisieren - 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. ''eingabe : - ''ausgabe : - ''busprotokoll : - sdmount 'sd-karte mounten bload(@belsys) 'vga-treiber zu bellatrix übertragen PUB paraset(stradr) | i,c 'system: parameter --> eram ''funktionsgruppe : system ''funktion : parameter --> eram - werden programme mit dem systemloader gestartet, so kann '' : mit dieser funktion ein parameterstring im eram übergeben werden. das gestartete '' : programm kann diesen dann mit "parastart" & "paranext" auslesen und verwenden ''eingabe : - ''ausgabe : stradr - adresse des parameterstrings ''busprotokoll : - paradel 'parameterbereich löschen repeat i from 0 to 63 'puffer ist mx. 64 zeichen lang c := byte[stradr+i] ram_wrbyte(0,c,PARAM+i) if c == 0 'bei stringende vorzeitig beenden return PUB paradel | i 'system: parameterbereich löschen ''funktionsgruppe : system ''funktion : parameterbereich im eram löschen ''eingabe : - ''ausgabe : - ''busprotokoll : - repeat i from 0 to 63 ram_wrbyte(0,0,PARAM+i) PUB parastart 'system: setzt den zeiger auf parameteranfangsposition ''funktionsgruppe : system ''funktion : setzt den index auf die parameteranfangsposition ''eingabe : - ''ausgabe : - ''busprotokoll : - parapos := 0 PUB paranext(stradr): err | i,c 'system: überträgt den nächsten parameter in stringdatei ''funktionsgruppe : system ''funktion : überträgt den nächsten parameter in stringdatei ''eingabe : stradr - adresse einer stringvariable für den nächsten parameter ''ausgabe : err - 0: kein weiterer parameter '' : 1: parameter gültig ''busprotokoll : - if ram_rdbyte(0,PARAM+parapos) <> 0 'stringende? repeat until ram_rdbyte(0,PARAM+parapos) > CHAR_SPACE 'führende leerzeichen ausblenden parapos++ i := 0 repeat 'parameter kopieren c := ram_rdbyte(0,PARAM + parapos++) if c <> CHAR_SPACE 'space nicht kopieren byte[stradr++] := c until (c == CHAR_SPACE) or (c == 0) byte[stradr] := 0 'string abschließen return 1 else return 0 PUB reggetcogs:regcogs |i,c,cog[8] 'system: fragt freie cogs von regnatix ab ''funktionsgruppe : system ''funktion : fragt freie cogs von regnatix ab ''eingabe : - ''ausgabe : regcogs - anzahl der belegten cogs ''busprotokoll : - regcogs := i := 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 regcogs := i repeat 'unloads the cogs and updates the string i-- if i=>0 cogstop(cog[i]) while i=>0 PUB stop 'loader: beendet anwendung und startet os ''funktionsgruppe : system ''funktion : beendet die laufende anwendung und kehrt zum os (reg.sys) zurück ''eingabe : - ''ausgabe : - ''busprotokoll : - sddmact(DM_ROOT) ldbin(@regsys) PUB ldbin(stradr) | len,i,stradr1,stradr2 'loader: startet bin-datei über loader ''funktionsgruppe : system ''funktion : startet bin-datei über den systemloader ''eingabe : stradr - adresse eines strings mit dem dateinamen der bin-datei ''ausgabe : - ''busprotokoll : - len := strsize(stradr) stradr2 := lflagadr + 1 'adr = flag, adr + 1 = string 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 OBJ '' A D M I N I S T R A CON ''------------------------------------------------- CHIP-MANAGMENT PUB admsetsound(sndfunktion):sndstat 'chip-mgr: soundsubsysteme verwalten ''funktionsgruppe : cmgr ''funktion : soundsubsysteme an- bzw. abschalten ''busprotokoll : [150][put.funktion][get.sndstat] '' : funktion - 0: hss-engine abschalten SND_HSSOFF '' : 1: hss-engine anschalten SND_HSSON '' : 2: dac-engine abschalten SND_WAVOFF '' : 3: dac-engine anschalten SND_WAVON '' : sndstat - status/cognr startvorgang bus_putchar1(AMGR_SETSOUND) bus_putchar1(sndfunktion) sndstat := bus_getchar1 PUB admsetsyssnd(status) 'chip-mgr: systemklänge ein/ausschalten ''funktionsgruppe : cmgr ''funktion : systemklänge steuern ''busprotokoll : [094][put.fl_syssnd] '' : fl_syssnd - flag zur steuerung der systemsounds '' : 0 - systemtöne aus '' : 1 - systemtöne an bus_putchar1(AMGR_SETSYSSOUND) bus_putchar1(status) PUB admgetsndsys: status 'chip-mgr: status des soundsystems abfragen ''funktionsgruppe : cmgr ''funktion : abfrage welches soundsystem aktiv ist ''busprotokoll : [095][get.status] '' : status - status des soundsystems '' : 0 - sound aus '' : 1 - hss '' : 2 - wav bus_putchar1(AMGR_GETSOUNDSYS) status := bus_getchar1 PUB admload(stradr)|dmu 'chip-mgr: neuen administra-code booten ''funktionsgruppe : cmgr ''funktion : administra mit neuem code booten ''busprotokoll : [096][sub_putstr.fn] '' : fn - dateiname des neuen administra-codes bus_putchar1(AMGR_ALOAD) 'aktuelles userdir retten bus_putstr1(stradr) waitcnt(cnt + clkfreq*3) 'warte bis administra fertig ist PUB admgetver:ver 'chip-mgr: version abfragen ''funktionsgruppe : cmgr ''funktion : abfrage der version und spezifikation des chips ''busprotokoll : [098][sub_getlong.ver] '' : ver - version '' +---------- '' | +------- system '' | | +---- version (änderungen) '' | | | +- subversion (hinzufügungen) ''version : $00_00_00_00 '' bus_putchar1(AMGR_GETVER) ver := bus_getlong1 PUB admgetspec:spec 'chip-mgr: spezifikation abfragen ''funktionsgruppe : cmgr ''funktion : abfrage der version und spezifikation des chips ''busprotokoll : [089][sub_getlong.spec] '' : spec - spezifikation '' '' +---------- com '' | +-------- i2c '' | |+------- rtc '' | ||+------ lan '' | |||+----- sid '' | ||||+---- wav '' | |||||+--- hss '' | ||||||+-- bootfähig '' | |||||||+- dateisystem ''spezifikation : %00000000_00000000_00000000_01001111 bus_putchar1(AMGR_GETSPEC) spec := bus_getlong1 PUB admgetcogs:cogs 'chip-mgr: verwendete cogs abfragen ''funktionsgruppe : cmgr ''funktion : abfrage wie viele cogs in benutzung sind ''busprotokoll : [097][get.cogs] '' : cogs - anzahl der belegten cogs bus_putchar1(AMGR_GETCOGS) cogs := bus_getchar1 PUB admreset 'chip-mgr: administra reset ''funktionsgruppe : cmgr ''funktion : reset im administra-chip auslösen - loader aus dem eeprom wird neu geladen ''busprotokoll : - bus_putchar1(AMGR_REBOOT) PUB admdebug: wert 'chip-mgr: debug-funktion bus_putchar1(AMGR_DEBUG) wert := bus_getlong1 CON ''------------------------------------------------- SD_LAUFWERKSFUNKTIONEN PUB sdmount: err 'sd-card: mounten ''funktionsgruppe : sdcard ''funktion : eingelegtes volume mounten ''busprotokoll : [001][get.err] '' : err - fehlernummer entspr. list bus_putchar1(SD_MOUNT) err := bus_getchar1 PUB sddir 'sd-card: verzeichnis wird geöffnet ''funktionsgruppe : sdcard ''funktion : verzeichnis öffnen ''busprotokoll : [002] bus_putchar1(SD_DIROPEN) PUB sdnext: stradr | flag 'sd-card: nächster dateiname aus verzeichnis ''funktionsgruppe : sdcard ''funktion : nächsten eintrag aus verzeichnis holen ''busprotokoll : [003][get.status=0] '' : [003][get.status=1][sub_getstr.fn] '' : status - 1 = gültiger eintrag '' : 0 = es folgt kein eintrag mehr '' : fn - verzeichniseintrag string bus_putchar1(SD_NEXTFILE) 'kommando: nächsten eintrag holen flag := bus_getchar1 'flag empfangen if flag return bus_getstr1 else return 0 PUB sdopen(modus,stradr):err | len,i 'sd-card: datei öffnen ''funktionsgruppe : sdcard ''funktion : eine bestehende datei öffnen ''busprotokoll : [004][put.modus][sub_putstr.fn][get.error] '' : modus - "A" Append, "W" Write, "R" Read (Großbuchstaben!) '' : fn - name der datei '' : error - fehlernummer entspr. list 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 sdclose:err 'sd-card: datei schließen ''funktionsgruppe : sdcard ''funktion : die aktuell geöffnete datei schließen ''busprotokoll : [005][get.error] '' : error - fehlernummer entspr. list bus_putchar1(SD_CLOSE) err := bus_getchar1 PUB sdgetc: char 'sd-card: zeichen aus datei lesen ''funktionsgruppe : sdcard ''funktion : zeichen aus datei lesen ''busprotokoll : [006][get.char] '' : char - gelesenes zeichen 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 sdgetstr(stringptr,len) 'sd-card: eingabe einer zeichenkette repeat len byte[stringptr++] := bus_getchar1 PUB sdputstr(stringptr) 'sd-card: ausgabe einer zeichenkette (0-terminiert) {{sdstr(stringptr) - sd-card: ausgabe einer zeichenkette (0-terminiert)}} repeat strsize(stringptr) sdputc(byte[stringptr++]) PUB sddec(value) | i 'sd-card: dezimalen zahlenwert auf bildschirm ausgeben {{sddec(value) - sd-card: dezimale bildschirmausgabe zahlenwertes}} if value < 0 'negativer zahlenwert -value sdputc("-") i := 1_000_000_000 repeat 10 'zahl zerlegen if value => i sdputc(value / i + "0") value //= i result~~ elseif result or i == 1 sdputc("0") i /= 10 'n?chste stelle PUB sdeof: eof 'sd-card: eof abfragen ''funktionsgruppe : sdcard ''funktion : eof abfragen ''busprotokoll : [030][get.eof] '' : eof - eof-flag bus_putchar1(SD_EOF) eof := bus_getchar1 PUB sdgetblk(count,bufadr) | i 'sd-card: block lesen ''funktionsgruppe : sdcard ''funktion : block aus datei lesen ''busprotokoll : [008][sub_putlong.count][get.char(1)]..[get.char(count)] '' : count - anzahl der zu lesenden zeichen '' : char - gelesenes zeichen i := 0 bus_putchar1(SD_GETBLK) bus_putlong1(count) repeat count byte[bufadr][i++] := bus_getchar1 PUB sdputblk(count,bufadr) | i 'sd-card: block schreiben ''funktionsgruppe : sdcard ''funktion : zeichen in datei schreiben ''busprotokoll : [007][put.char] '' : char - zu schreibendes zeichen i := 0 bus_putchar1(SD_PUTBLK) bus_putlong1(count) repeat count bus_putchar1(byte[bufadr][i++]) PUB sdxgetblk(fnr,count)|i 'sd-card: block lesen --> eRAM ''funktionsgruppe : sdcard ''funktion : block aus datei lesen und in ramdisk speichern ''busprotokoll : [008][sub_putlong.count][get.char(1)]..[get.char(count)] '' : count - anzahl der zu lesenden zeichen '' : char - gelesenes zeichen i := 0 bus_putchar1(SD_GETBLK) bus_putlong1(count) repeat count rd_put(fnr,bus_getchar1) PUB sdxputblk(fnr,count)|i 'sd-card: block schreiben <-- eRAM ''funktionsgruppe : sdcard ''funktion : zeichen aus ramdisk in datei schreiben ''busprotokoll : [007][put.char] '' : char - zu schreibendes zeichen i := 0 bus_putchar1(SD_PUTBLK) bus_putlong1(count) repeat count bus_putchar1(rd_get(fnr)) PUB sdseek(wert) 'sd-card: zeiger auf byteposition setzen ''funktionsgruppe : sdcard ''funktion : zeiger in datei positionieren ''busprotokoll : [010][sub_putlong.pos] '' : pos - neue zeichenposition in der datei bus_putchar1(SD_SEEK) bus_putlong1(wert) PUB sdfattrib(anr): attrib 'sd-card: dateiattribute abfragen ''funktionsgruppe : sdcard ''funktion : dateiattribute abfragen ''busprotokoll : [011][put.anr][sub_getlong.wert] '' : anr - 0 = Dateigröße '' : 1 = Erstellungsdatum - Tag '' : 2 = Erstellungsdatum - Monat '' : 3 = Erstellungsdatum - Jahr '' : 4 = Erstellungsdatum - Sekunden '' : 5 = Erstellungsdatum - Minuten '' : 6 = Erstellungsdatum - Stunden '' : 7 = Zugriffsdatum - Tag '' : 8 = Zugriffsdatum - Monat '' : 9 = Zugriffsdatum - Jahr '' : 10 = Änderungsdatum - Tag '' : 11 = Änderungsdatum - Monat '' : 12 = Änderungsdatum - Jahr '' : 13 = Änderungsdatum - Sekunden '' : 14 = Änderungsdatum - Minuten '' : 15 = Änderungsdatum - Stunden '' : 16 = Read-Only-Bit '' : 17 = Hidden-Bit '' : 18 = System-Bit '' : 19 = Direktory '' : 20 = Archiv-Bit '' : wert - wert des abgefragten attributes bus_putchar1(SD_FATTRIB) bus_putchar1(anr) attrib := bus_getlong1 PUB sdvolname: stradr | len,i 'sd-card: volumelabel abfragen ''funktionsgruppe : sdcard ''funktion : name des volumes überragen ''busprotokoll : [012][sub_getstr.volname] '' : volname - name des volumes '' : len - länge des folgenden strings bus_putchar1(SD_VOLNAME) 'kommando: volumelabel abfragen return bus_getstr1 PUB sdcheckmounted: flag 'sd-card: test ob volume gemounted ist ''funktionsgruppe : sdcard ''funktion : test ob volume gemounted ist ''busprotokoll : [013][get.flag] '' : flag - 0: unmounted '' : 1: mounted bus_putchar1(SD_CHECKMOUNTED) return bus_getchar1 PUB sdcheckopen: flag 'sd-card: test ob datei geöffnet ist ''funktionsgruppe : sdcard ''funktion : test ob eine datei geöffnet ist ''busprotokoll : [014][get.flag] '' : flag - 0: not open '' : 1: open bus_putchar1(SD_CHECKOPEN) return bus_getchar1 PUB sdcheckused 'sd-card: abfrage der benutzten sektoren ''funktionsgruppe : sdcard ''funktion : anzahl der benutzten sektoren senden ''busprotokoll : [015][sub_getlong.used] '' : used - anzahl der benutzten sektoren bus_putchar1(SD_CHECKUSED) return bus_getlong1 PUB sdcheckfree 'sd_card: abfrage der freien sektoren ''funktionsgruppe : sdcard ''funktion : anzahl der freien sektoren senden ''busprotokoll : [016][sub_getlong.free] '' : free - anzahl der freien sektoren bus_putchar1(SD_CHECKFREE) return bus_getlong1 PUB sdnewfile(stradr):err 'sd_card: neue datei erzeugen ''funktionsgruppe : sdcard ''funktion : eine neue datei erzeugen ''busprotokoll : [017][sub_putstr.fn][get.error] '' : fn - name der datei '' : error - fehlernummer entspr. liste bus_putchar1(SD_NEWFILE) bus_putstr1(stradr) err := bus_getchar1 PUB sdnewdir(stradr):err 'sd_card: neues verzeichnis erzeugen ''funktionsgruppe : sdcard ''funktion : ein neues verzeichnis erzeugen ''busprotokoll : [018][sub_putstr.fn][get.error] '' : fn - name des verzeichnisses '' : error - fehlernummer entspr. liste bus_putchar1(SD_NEWDIR) bus_putstr1(stradr) err := bus_getchar1 PUB sddel(stradr):err 'sd_card: datei/verzeichnis löschen ''funktionsgruppe : sdcard ''funktion : eine datei oder ein verzeichnis löschen ''busprotokoll : [019][sub_putstr.fn][get.error] '' : fn - name des verzeichnisses oder der datei '' : error - fehlernummer entspr. liste bus_putchar1(SD_DEL) bus_putstr1(stradr) err := bus_getchar1 PUB sdrename(stradr1,stradr2):err 'sd_card: datei/verzeichnis umbenennen ''funktionsgruppe : sdcard ''funktion : datei oder verzeichnis umbenennen ''busprotokoll : [020][sub_putstr.fn1][sub_putstr.fn2][get.error] '' : fn1 - alter name '' : fn2 - neuer name '' : error - fehlernummer entspr. liste bus_putchar1(SD_RENAME) bus_putstr1(stradr1) bus_putstr1(stradr2) err := bus_getchar1 PUB sdchattrib(stradr1,stradr2):err 'sd-card: attribute ändern ''funktionsgruppe : sdcard ''funktion : attribute einer datei oder eines verzeichnisses ändern ''busprotokoll : [021][sub_putstr.fn][sub_putstr.attrib][get.error] '' : fn - dateiname '' : attrib - string mit attributen (AHSR) '' : error - fehlernummer entspr. liste bus_putchar1(SD_CHATTRIB) bus_putstr1(stradr1) bus_putstr1(stradr2) err := bus_getchar1 PUB sdchdir(stradr):err 'sd-card: verzeichnis wechseln ''funktionsgruppe : sdcard ''funktion : verzeichnis wechseln ''busprotokoll : [022][sub_putstr.fn][get.error] '' : fn - name des verzeichnisses '' : error - fehlernummer entspr. list bus_putchar1(SD_CHDIR) bus_putstr1(stradr) err := bus_getchar1 PUB sdformat(stradr):err 'sd-card: medium formatieren ''funktionsgruppe : sdcard ''funktion : medium formatieren ''busprotokoll : [023][sub_putstr.vlabel][get.error] '' : vlabel - volumelabel '' : error - fehlernummer entspr. list bus_putchar1(SD_FORMAT) bus_putstr1(stradr) err := bus_getchar1 PUB sdunmount:err 'sd-card: medium abmelden ''funktionsgruppe : sdcard ''funktion : medium abmelden ''busprotokoll : [024][get.error] '' : error - fehlernummer entspr. list bus_putchar1(SD_UNMOUNT) err := bus_getchar1 PUB sddmact(marker):err 'sd-card: dir-marker aktivieren ''funktionsgruppe : sdcard ''funktion : ein ausgewählter dir-marker wird aktiviert ''busprotokoll : [025][put.dmarker][get.error] '' : dmarker - dir-marker '' : error - fehlernummer entspr. list bus_putchar1(SD_DMACT) bus_putchar1(marker) err := bus_getchar1 PUB sddmset(marker) 'sd-card: dir-marker setzen ''funktionsgruppe : sdcard ''funktion : ein ausgewählter dir-marker mit dem aktuellen verzeichnis setzen ''busprotokoll : [026][put.dmarker] '' : dmarker - dir-marker bus_putchar1(SD_DMSET) bus_putchar1(marker) PUB sddmget(marker):status 'sd-card: dir-marker abfragen ''funktionsgruppe : sdcard ''funktion : den status eines ausgewählter dir-marker abfragen ''busprotokoll : [027][put.dmarker][sub_getlong.dmstatus] '' : dmarker - dir-marker '' : dmstatus - status des markers bus_putchar1(SD_DMGET) bus_putchar1(marker) status := bus_getlong1 PUB sddmclr(marker) 'sd-card: dir-marker löschen ''funktionsgruppe : sdcard ''funktion : ein ausgewählter dir-marker löschen ''busprotokoll : [028][put.dmarker] '' : dmarker - dir-marker bus_putchar1(SD_DMCLR) bus_putchar1(marker) PUB sddmput(marker,status) 'sd-card: dir-marker status setzen ''funktionsgruppe : sdcard ''funktion : dir-marker status setzen ''busprotokoll : [027][put.dmarker][sub_putlong.dmstatus] '' : dmarker - dir-marker '' : dmstatus - status des markers bus_putchar1(SD_DMPUT) bus_putchar1(marker) bus_putlong1(status) CON ''------------------------------------------------- PlexBus PUB plx_open(plxnr):err 'plx: plexus öffnen bus_putchar1(P_OPEN) bus_putchar1(plxnr) err := bus_getchar1 PUB plx_close:err 'plx: plexus schliessen bus_putchar1(P_CLOSE) err := bus_getchar1 PUB plx_put(char) 'plx: zeichen an plexus senden bus_putchar1(P_PUT) bus_putchar1(char) PUB plx_get:char 'plx: zeichen vom plexus empfangen bus_putchar1(P_GET) char := bus_getchar1 PUB plx_reset 'plx: plexbus rücksetzen bus_putchar1(P_RESET) CON ''------------------------------------------------- Hydra Sound System PUB hss_playfile(stradr) | status 'hss: spielt übergebene hss-datei von sd-card ''funktionsgruppe : hss ''funktion : hss-datei wird in den puffer in administra geladen und der player gestartet '' : stradr - stringadresse zu dateinamen status := hss_load(stradr) hss_play PUB hss_stop 'hss: stopt aktuellen song ''funktionsgruppe : hss ''funktion : hss-player stoppen; datei bleibt im puffer bus_putchar1(CHSS_STOP) PUB hss_pause 'hss: pausiert aktuellen song ''funktionsgruppe : hss ''funktion : hss-player pause (funktion noch unklar) bus_putchar1(CHSS_PAUSE) PUB hss_load(stradr): status | len,i 'hss: lädt hss-datei von sd-card in songpuffer ''funktionsgruppe : hss ''funktion : hss-datei wird in den modulpuffer geladen ''busprotokoll : [100][sub_putstr.fn][get.err] '' : fn - dateiname '' : err - fehlernummer entspr. liste bus_putchar1(CHSS_LOAD) bus_putstr1(stradr) status := bus_getchar1 PUB hss_play 'hss: spielt song im puffer ab ''funktionsgruppe : hss ''funktion : hss-player starten und modul im puffer wiedergeben bus_putchar1(CHSS_PLAY) PUB hss_vol(vol) 'hss: volume einstellen 0..15 ''funktionsgruppe : hss ''funktion : lautstärke des hss-players wird eingestellt ''busprotokoll : [106][put.vol] '' : vol - 0..15 gesamtlautstärke des hss-players bus_putchar1(CHSS_VOL) bus_putchar1(vol) PUB hss_peek(n): wert 'hss: registerwert auslesen ''funktionsgruppe : hss ''funktion : zugriff auf die internen playerregister; leider sind die register '' : nicht dokumentiert; 48 long-register ''eingabe : - ''ausgabe : - ''busprotokoll : [104][put.regnr][sub_getlong.regwert] '' : regnr - registernummer '' : regwert - long bus_putchar1(CHSS_PEEK) 'kommando peek senden bus_putchar1(n) 'kommando peek senden wert := bus_getlong1 '32-bit-wert lesen PUB hss_intreg(n): wert 'hss: interfaceregister auslesen ''funktionsgruppe : hss ''funktion : abfrage eines hss-playerregisters (16bit) durch regnatix ''busprotokoll : [105][put.regnr][get.reghwt][get.regnwt] '' : regnr - 0..24 (5 x 5 register) '' : reghwt - höherwertiger teil des 16bit-registerwertes '' : regnwt - niederwertiger teil des 16bit-registerwertes '' ''0 iEndFlag iRowFlag iEngineC iBeatC iRepeat globale Playerwerte ''5 iNote iOktave iVolume iEffekt iInstrument Soundkanal 1 ''10 iNote iOktave iVolume iEffekt iInstrument Soundkanal 2 ''15 iNote iOktave iVolume iEffekt iInstrument Soundkanal 3 ''20 iNote iOktave iVolume iEffekt iInstrument Soundkanal 4 '' ''iEndFlag Repeat oder Ende wurde erreicht ''iRowFlag Trackerzeile (Row) ist fertig ''iEngineC Patternzähler ''iBeatC Beatzähler (Anzahl der Rows) ''iRepeat Zähler für Loops bus_putchar1(CHSS_INTREG) 'kommando peek senden bus_putchar1(n) 'kommando peek senden wert := bus_getchar1 '16-bit-wert lesen, hsb/lsb wert := (wert<<8) + bus_getchar1 PUB sfx_setslot(adr,slot) | i,n 'sfx: sendet sfx-daten in sfx-slot ''funktionsgruppe : sfx ''funktion : die daten für ein sfx-slot werden werden von regnatix gesetzt ''eingabe : - ''ausgabe : - ''busprotokoll : [108][put.slot][put.daten(0)]..[put.daten(31)] '' : slot - $00..$0f nummer der freien effektpuffer '' : daten - 32 byte effektdaten '' ''struktur der effektdaten: '' ''[wav ][len ][freq][vol ] grundschwingung ''[lfo ][lfw ][fma ][ama ] modulation ''[att ][dec ][sus ][rel ] hüllkurve ''[seq ] (optional) '' ''[wav] wellenform '' 0 sinus (0..500hz) '' 1 schneller sinus (0..1khz) '' 2 dreieck (0..500hz) '' 3 rechteck (0..1khz) '' 4 schnelles rechteck (0..4khz) '' 5 impulse (0..1,333hz) '' 6 rauschen ''[len] tonlänge $0..$fe, $ff endlos ''[freq] frequenz $00..$ff ''[vol] lautstärke $00..$0f '' ''[lfo] low frequency oscillator $ff..$01 ''[lfw] low frequency waveform '' $00 sinus (0..8hz) '' $01 fast sine (0..16hz) '' $02 ramp up (0..8hz) '' $03 ramp down (0..8hz) '' $04 square (0..32hz) '' $05 random '' $ff sequencer data (es folgt eine sequenzfolge [seq]) ''[fma] frequency modulation amount '' $00 no modulation '' $01..$ff ''[ama] amplitude modulation amount '' $00 no modulation '' $01..$ff ''[att] attack $00..$ff ''[dec] decay $00..$ff ''[sus] sustain $00..$ff ''[rel] release $00..$ff bus_putchar1(CSFX_SETSLOT) bus_putchar1(slot) 'slotnummer senden repeat i from 0 to 31 '32 byte sfx-daten senden n := byte[adr + i] bus_putchar1(n) PUB sfx_fire(slot,chan) 'sfx: triggert einen bestimmten soundeffekt ''funktionsgruppe : sfx ''funktion : effekt aus einem effektpuffer abspielen ''busprotokoll : [107][put.slot][put.chan] '' : slot - $00..$0f nummer der freien effektpuffer '' : slot - $f0..f5 vordefinierte effektslots '' : chan - 0/1 stereokanal auf dem der effekt abgespielt werden soll ''vordefinierte effekte : &f0 - warnton '' : $f1 - signalton '' : $f2 - herzschlag schnell '' : $f3 - herzschlag langsam '' : $f4 - telefon '' : $f5 - phaser :) bus_putchar1(CSFX_FIRE) bus_putchar1(slot) 'slotnummer senden bus_putchar1(chan) 'channel senden CON ''------------------------------------------------- Wave PUB wav_play(stradr): status | len,i 'sdw: spielt wav-datei direkt von sd-card ''funktionsgruppe : sdw ''funktion : wav-datei von sd-card abspielen ''busprotokoll : [150][sub.putstr][get.err] '' : err - fehlernummer entspr. liste bus_putchar1(SDW_START) bus_putstr1(stradr) status := bus_getchar1 PUB wav_stop:status 'sdw: wave-wiedergabe beenden ''funktionsgruppe : sdw ''funktion : wav-player signal zum stoppen senden '' : wartet bis player endet und quitiert erst dann ''busprotokoll : [151][get.err] '' : err - fehlernummer entspr. liste bus_putchar1(SDW_STOP) status := bus_getchar1 PUB wav_status: status 'sdw: status des players abfragen ''funktionsgruppe : sdw ''funktion : status des wav-players abfragen ''busprotokoll : [152][get.status] '' : status - status des wav-players '' : 0: wav fertig (player beendet) '' : 1: wav wird abgespielt bus_putchar1(SDW_STATUS) status := bus_getchar1 PUB wav_lvol(vol) 'sdw: linke lautstärke einstellen ''funktionsgruppe : sdw ''funktion : lautstärke links einstellen ''busprotokoll : [153][get.vol] '' : vol - lautstärke 0..100 bus_putchar1(SDW_LVOL) bus_putchar1(vol) PUB wav_rvol(vol) 'sdw: rechte lautstärke einstellen ''funktionsgruppe : sdw ''funktion : lautstärke rechts einstellen ''busprotokoll : [154][get.vol] '' : vol - lautstärke 0..100 bus_putchar1(SDW_RVOL) bus_putchar1(vol) PUB wav_pause:status 'sdw: wave-pause ''funktionsgruppe : sdw ''funktion : wav-player signal für pause/weiter senden '' : wartet bis player endet und quitiert erst dann ''busprotokoll : [151][get.err] '' : err - fehlernummer entspr. liste bus_putchar1(SDW_PAUSE) status := bus_getchar1 PUB wav_len:len 'sdw: wav-länge abfragen ''funktionsgruppe : sdw ''funktion : wav-länge abfragen ''busprotokoll : [154][sub_getlong.pos][sub_getlong.len] '' : len - länge wav-datei '' : pos - position in der wav-datei bus_putchar1(SDW_POS) bus_getlong1 len := bus_getlong1 PUB wav_pos:pos 'sdw: wav-position abfragen ''funktionsgruppe : sdw ''funktion : wav-länge abfragen ''busprotokoll : [154][sub_getlong.pos][sub_getlong.len] '' : len - länge wav-datei '' : pos - position in der wav-datei bus_putchar1(SDW_POS) pos := bus_getlong1 bus_getlong1 CON ''------------------------------------------------- SIDCog DMP-Player PUB sid_mdmpplay(stradr): err 'sid: dmp-datei mono auf sid2 abspielen ''funktionsgruppe : sid ''funktion : dmp-datei auf sid2 von sd-card abspielen ''busprotokoll : [157][sub.putstr][get.err] '' : err - fehlernummer entspr. liste bus_putchar1(SCOG_MDMPPLAY) bus_putstr1(stradr) err := bus_getchar1 PUB sid_sdmpplay(stradr): err 'sid: dmp-datei stereo auf beiden sid's abspielen ''funktionsgruppe : sid ''funktion : sid: dmp-datei stereo auf beiden sid's abspielen ''busprotokoll : [158][sub.putstr][get.err] '' : err - fehlernummer entspr. liste bus_putchar1(SCOG_SDMPPLAY) bus_putstr1(stradr) err := bus_getchar1 PUB sid_dmpstop bus_putchar1(SCOG_DMPSTOP) PUB sid_dmppause bus_putchar1(SCOG_DMPPAUSE) PUB sid_dmpstatus: status bus_putchar1(SCOG_DMPSTATUS) status := bus_getchar1 PUB sid_dmppos: wert bus_putchar1(SCOG_DMPPOS) wert := bus_getlong1 bus_getlong1 PUB sid_dmplen: wert bus_putchar1(SCOG_DMPPOS) bus_getlong1 wert := bus_getlong1 PUB sid_mute(sidnr) 'sid: chips stummschalten bus_putchar1(SCOG_MUTE) bus_putchar1(sidnr) CON ''------------------------------------------------- SIDCog1-Funktionen PUB sid1_setRegister(reg,val) bus_putchar1(SCOG1_setRegister) bus_putchar1(reg) bus_putchar1(val) PUB sid1_updateRegisters(regadr)|i bus_putchar1(SCOG1_setRegister) repeat 25 bus_putchar1(byte[regadr++]) PUB sid1_setVolume(vol) bus_putchar1(SCOG1_setVolume) bus_putchar1(vol) PUB sid1_play(channel, freq, waveform, attack, decay, sustain, release) bus_putchar1(SCOG1_play) bus_putchar1(channel) bus_putlong1(freq) bus_putchar1(waveform) bus_putchar1(attack) bus_putchar1(decay) bus_putchar1(sustain) bus_putchar1(release) PUB sid1_noteOn(channel, freq) bus_putchar1(SCOG1_noteOn) bus_putchar1(channel) bus_putlong1(freq) PUB sid1_noteOff(channel) bus_putchar1(SCOG1_noteOff) bus_putchar1(channel) PUB sid1_setFreq(channel,freq) bus_putchar1(SCOG1_setFreq) bus_putchar1(channel) bus_putlong1(freq) PUB sid1_setWaveform(channel,waveform) bus_putchar1(SCOG1_setWaveform) bus_putchar1(channel) bus_putchar1(waveform) PUB sid1_setPWM(channel, val) bus_putchar1(SCOG1_setPWM) bus_putchar1(channel) bus_putlong1(val) PUB sid1_setADSR(channel, attack, decay, sustain, release ) bus_putchar1(SCOG1_setADSR) bus_putchar1(channel) bus_putchar1(attack) bus_putchar1(decay) bus_putchar1(sustain) bus_putchar1(release) PUB sid1_setResonance(val) bus_putchar1(SCOG1_setResonance) bus_putchar1(val) PUB sid1_setCutoff(freq) bus_putchar1(SCOG1_setCutoff) bus_putlong1(freq) PUB sid1_setFilterMask(ch1,ch2,ch3) bus_putchar1(SCOG1_setFilterMask) bus_putchar1(ch1) bus_putchar1(ch2) bus_putchar1(ch3) PUB sid1_setFilterType(lp,bp,hp) bus_putchar1(SCOG1_setFilterType) bus_putchar1(lp) bus_putchar1(bp) bus_putchar1(hp) PUB sid1_enableRingmod(ch1,ch2,ch3) bus_putchar1(SCOG1_enableRingmod) bus_putchar1(ch1) bus_putchar1(ch2) bus_putchar1(ch3) PUB sid1_enableSynchronization(ch1,ch2,ch3) bus_putchar1(SCOG1_enableSynchronization) bus_putchar1(ch1) bus_putchar1(ch2) bus_putchar1(ch3) CON ''------------------------------------------------- SIDCog2-Funktionen PUB sid2_setRegister(reg,val) bus_putchar1(SCOG2_setRegister) bus_putchar1(reg) bus_putchar1(val) PUB sid2_updateRegisters(regadr)|i bus_putchar1(SCOG2_setRegister) repeat 25 bus_putchar1(byte[regadr++]) PUB sid2_setVolume(vol) bus_putchar1(SCOG2_setVolume) bus_putchar1(vol) PUB sid2_play(channel, freq, waveform, attack, decay, sustain, release) bus_putchar1(SCOG2_play) bus_putchar1(channel) bus_putlong1(freq) bus_putchar1(waveform) bus_putchar1(attack) bus_putchar1(decay) bus_putchar1(sustain) bus_putchar1(release) PUB sid2_noteOn(channel, freq) bus_putchar1(SCOG2_noteOn) bus_putchar1(channel) bus_putlong1(freq) PUB sid2_noteOff(channel) bus_putchar1(SCOG2_noteOff) bus_putchar1(channel) PUB sid2_setFreq(channel,freq) bus_putchar1(SCOG2_setFreq) bus_putchar1(channel) bus_putlong1(freq) PUB sid2_setWaveform(channel,waveform) bus_putchar1(SCOG2_setWaveform) bus_putchar1(channel) bus_putchar1(waveform) PUB sid2_setPWM(channel, val) bus_putchar1(SCOG2_setPWM) bus_putchar1(channel) bus_putlong1(val) PUB sid2_setADSR(channel, attack, decay, sustain, release ) bus_putchar1(SCOG2_setADSR) bus_putchar1(channel) bus_putchar1(attack) bus_putchar1(decay) bus_putchar1(sustain) bus_putchar1(release) PUB sid2_setResonance(val) bus_putchar1(SCOG2_setResonance) bus_putchar1(val) PUB sid2_setCutoff(freq) bus_putchar1(SCOG2_setCutoff) bus_putlong1(freq) PUB sid2_setFilterMask(ch1,ch2,ch3) bus_putchar1(SCOG2_setFilterMask) bus_putchar1(ch1) bus_putchar1(ch2) bus_putchar1(ch3) PUB sid2_setFilterType(lp,bp,hp) bus_putchar1(SCOG2_setFilterType) bus_putchar1(lp) bus_putchar1(bp) bus_putchar1(hp) PUB sid2_enableRingmod(ch1,ch2,ch3) bus_putchar1(SCOG2_enableRingmod) bus_putchar1(ch1) bus_putchar1(ch2) bus_putchar1(ch3) PUB sid2_enableSynchronization(ch1,ch2,ch3) bus_putchar1(SCOG2_enableSynchronization) bus_putchar1(ch1) bus_putchar1(ch2) bus_putchar1(ch3) OBJ '' B E L L A T R I X CON ''------------------------------------------------- CHIP-MANAGMENT PUB belsetcolor(cnr,color) 'chip-mgr: farbregister setzen ''funktionsgruppe : cmgr ''funktion : farbregister setzen ''busprotokoll : [cmd][put.cnr][sub_putlong.color] '' : cnr - nummer des farbregisters 0..15 '' : color - erster wert bus_putchar2(BEL_CMD) 'kommandosequenz einleiten bus_putchar2(BMGR_SETCOLOR) bus_putchar2(cnr) bus_putlong2(color) PUB belgetcolor(cnr):color 'chip-mgr: farbregister abfragen ''funktionsgruppe : cmgr ''funktion : farbregister abfragen ''busprotokoll : [cmd][put.cnr][sub_getong.color] '' : cnr - nummer des farbregisters 0..15 '' : color - erster wert bus_putchar2(BEL_CMD) 'kommandosequenz einleiten bus_putchar2(BMGR_GETCOLOR) bus_putchar2(cnr) color := bus_getlong2 PUB belgetresx:resx 'chip-mgr: x-auflösung abfragen ''funktionsgruppe : cmgr ''funktion : x-auflösung abfragen ''busprotokoll : [cmd][sub_getlong.resx] '' : resx - x-auflösung bus_putchar2(BEL_CMD) 'kommandosequenz einleiten bus_putchar2(BMGR_GETRESX) resx := bus_getlong2 PUB belgetresy:resy 'chip-mgr: y-auflösung abfragen ''funktionsgruppe : cmgr ''funktion : y-auflösung abfragen ''busprotokoll : [cmd][sub_getlong.resy] '' : resy - y-auflösung bus_putchar2(BEL_CMD) 'kommandosequenz einleiten bus_putchar2(BMGR_GETRESY) resy := bus_getlong2 PUB belgetcols:cols 'chip-mgr: anzahl der textspalten abfragen ''funktionsgruppe : cmgr ''funktion : anzahl der textspalten abfragen ''busprotokoll : [cmd][get.cols] '' : rows - anzahl der textspalten bus_putchar2(BEL_CMD) 'kommandosequenz einleiten bus_putchar2(BMGR_GETCOLS) cols := bus_getchar2 PUB belgetrows:rows 'chip-mgr: anzahl der textzeilen abfragen ''funktionsgruppe : cmgr ''funktion : anzahl der textzeilen abfragen ''busprotokoll : [cmd][get.rows] '' : rows - anzahl der textzeilen bus_putchar2(BEL_CMD) 'kommandosequenz einleiten bus_putchar2(BMGR_GETROWS) rows := bus_getchar2 PUB belgetver:ver 'chip-mgr: version abfragen ''funktionsgruppe : cmgr ''funktion : abfrage der version und spezifikation des chips ''busprotokoll : [cmd][sub_getlong.ver] '' : ver - version '' '' +---------- '' | +------- system '' | | +---- version (änderungen) '' | | | +- subversion (hinzufügungen) ''version = $00_01_01_01 bus_putchar2(BEL_CMD) 'kommandosequenz einleiten bus_putchar2(BMGR_GETVER) ver := bus_getlong2 PUB belgetspec:spec 'chip-mgr: spezifikationen abfragen ''funktionsgruppe : cmgr ''funktion : abfrage der version und spezifikation des chips ''busprotokoll : [089][sub_getlong.spec] '' : spec - spezifikation '' '' '' +---------- '' | +-------- '' | |+------- vektor '' | ||+------ grafik '' | |||+----- text '' | ||||+---- maus '' | |||||+--- tastatur '' | ||||||+-- vga '' | |||||||+- tv ''spezifikation = %00000000_00000000_00000000_00010110 bus_putchar2(BEL_CMD) 'kommandosequenz einleiten bus_putchar2(BMGR_GETSPEC) spec := bus_getlong2 PUB belgetcogs:belcogs 'chip-mgr: verwendete cogs abfragen bus_putchar2(BEL_CMD) 'kommandosequenz einleiten bus_putchar2(BMGR_GETCOGS) 'code 5 = freie cogs belcogs := bus_getchar2 'statuswert empfangen PUB belreset 'chip-mgr: bellatrix reset {{breset - bellatrix neu starten}} bus_putchar2(BEL_CMD) 'kommandosequenz einleiten bus_putchar2(BMGR_REBOOT) 'code 99 = reboot PUB belload(stradr)| n,rc,ii,plen 'chip-mgr: neuen bellatrix-code booten belreset 'bellatrix neu starten waitcnt(cnt + 200_000_000) 'warte bis bel fertig ist bload(stradr) waitcnt(cnt + 200_000_000) 'warte bis bel fertig ist PUB bload(stradr) | n,rc,ii,plen 'system: bellatrix mit grafiktreiber initialisieren {{bload(stradr) - bellatrix mit grafiktreiber initialisieren wird zusätzlich zu belload gebraucht, da situationen auftreten, in denen bella ohne reset (kaltstart) mit einem treiber versorgt werden muß. ist der bella-loader aktiv, reagiert er nicht auf das reset-kommando. 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 CON ''------------------------------------------------- KEYBOARD 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 CON ''------------------------------------------------- SCREEN 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_rdbyte(1,eadr) repeat i from 1 to len eadr++ bus_putchar2(ram_rdbyte(1,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 printbin(value, digits) 'screen: binären zahlenwert auf bildschirm ausgeben value <<= 32 - digits repeat digits printchar((value <-= 1) & 1 + "0") PUB printchar(c):c2 'screen: einzelnes zeichen auf bildschirm ausgeben {{printchar(c) - screen: bildschirmausgabe eines zeichens}} bus_putchar2(c) c2 := c PUB printqchar(c):c2 'screen: zeichen ohne steuerzeichen ausgeben {{printqchar(c) - screen: bildschirmausgabe eines zeichens}} bus_putchar2(0) bus_putchar2(6) bus_putchar2(c) c2 := 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 printlogo(x,y) 'screen: logo ausgeben bus_putchar2($0) 'kommandosequenz einleiten bus_putchar2(PRN_LOGO) 'logo ausgeben bus_putchar2(x) bus_putchar2(y) 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 eline(n) 'screen: endzeile scrollbereich setzen {{sline(n) - endzeile scrollbereich setzen}} printctrl($12) 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 settabs(tnr,tpos) 'screen: setzt eine tabulatorposition printctrl($18) bus_putchar2(tnr) bus_putchar2(tpos) PUB screeninit(stradr,n) 'screen: löschen, kopfzeile ausgeben und setzen {{screeninit(stradr,n) - screen löschen, kopfzeile ausgeben und setzen}} curoff printctrl($13) if stradr > 0 print(stradr) printnl else printnl printlogo(0,0) sline(n) curhome curon ram_wrbyte(0,0,SIFLAG) OBJ '' R E G N A T I X CON ''------------------------------------------------- BUS 'prop 1 - administra (bus_putchar1, bus_getchar1) 'prop 2 - bellatrix (bus_putchar2, bus_getchar2) PUB bus_init 'bus: initialisiert bussystem {{bus_init - bus: initialisierung aller bussignale }} outa[bus_wr] := 1 ' schreiben inaktiv 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[reg_al] := 0 ' strobe aus 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 PUB bus_putchar1(c) 'bus: byte an 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 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_getlong1: wert 'bus: long von administra empfangen hsb/lsb wert := bus_getchar1 << 24 '32 bit empfangen hsb/lsb wert := wert + bus_getchar1 << 16 wert := wert + bus_getchar1 << 8 wert := wert + bus_getchar1 PUB bus_putlong1(wert) 'bus: long zu administra senden hsb/lsb bus_putchar1(wert >> 24) '32bit wert senden hsb/lsb bus_putchar1(wert >> 16) bus_putchar1(wert >> 8) bus_putchar1(wert) PUB bus_getstr1: stradr | len,i 'bus: string von administra empfangen len := bus_getchar1 'längenbyte empfangen repeat i from 0 to len - 1 '20 zeichen dateinamen empfangen strpuffer[i] := bus_getchar1 strpuffer[i] := 0 return @strpuffer PUB bus_putstr1(stradr) | len,i 'bus: string zu administra senden len := strsize(stradr) bus_putchar1(len) repeat i from 0 to len - 1 bus_putchar1(byte[stradr++]) 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 PUB bus_getlong2: wert 'bus: long von bellatrix empfangen hsb/lsb wert := bus_getchar2 << 24 '32 bit empfangen hsb/lsb wert := wert + bus_getchar2 << 16 wert := wert + bus_getchar2 << 8 wert := wert + bus_getchar2 PUB bus_putlong2(wert) 'bus: long an bellatrix senden hsb/lsb bus_putchar2(wert >> 24) '32bit wert senden hsb/lsb bus_putchar2(wert >> 16) bus_putchar2(wert >> 8) bus_putchar2(wert) CON ''------------------------------------------------- eRAM/SPEICHERVERWALTUNG { memory-map: 0000 --> datei 1 datei 2 ... datei n rbas --> usermem start ... rend --> usermen ende sysvar --> systemvariablen aufbau datei ramdisk: 1 long zeiger auf nächste datei (oder 0 bei letzter datei) 1 long datenlänge 12 byte dateiname nn byte daten aufbau ftab: fnr dateinummer fnr 0 usermem fnr 1..7 dateien fix := fnr * FCNT index in ftab ftab[fix+0] startadresse daten ftab[fix+1] endadresse daten ftab[fix+2] position in datei } CON STARTRD = 0 'startadresse der ramdisk FILES = 8 'maximale anzahl von RAMDisk-Dateien, die gleichzeitig geöffnet werden können FTCNT = 3 'anzahl longs pro eintrag sysmod = 0 usrmod = 1 RDHLEN = 20 ' 4+4+12 - headerlänge VAR long ftab[(files)*FTCNT] 'filedeskriptortabelle '1. long = startadresse daten '2. long = endadresse daten '3. long = position in der datei long dpos 'position im dir (dir/next) byte dstr[13] 'string für dateinamen DAT rdinit byte "ramdisk1.ram",0 PUB rd_open(stradr):fnr | adr,eadr,fix 'ramdisk: datei öffnen 'fnr = 0 - fehler 'fnr > 0 - nummer der geöffneten datei 'datei suchen, adresse ermitteln ifnot adr := rd_searchadr(stradr) return 0 'freien eintrag in ftab suchen fix := 0 repeat FILES if ftab[fix] == -1 quit fix += 3 if fix > FILES * FTCNT return -1 'eintrag setzen if (eadr := ram_rdlong(sysmod,adr)) eadr-- 'nicht letzte datei else eadr := rbas -1 'letzte datei (zeiger = 0), es folgt usermem ftab[fix+0] := adr + RDHLEN 'startadresse daten ftab[fix+1] := eadr 'endadresse daten ftab[fix+2] := 0 'position rücksetzen fnr := fix/3 PUB rd_close(fnr) | fix 'ramdisk: datei schliessen if (fnr > 0) AND (fnr =< FILES) fix := fnr * FTCNT ftab[fix+0] := -1 'startadresse daten ftab[fix+1] := -1 'endadresse daten ftab[fix+2] := -1 'position PUB rd_getftab(fix): wert 'ramdisk: ftab auslesen wert := ftab[fix] PUB rd_getinit: flag 'ramdisk: abfrage ob rd initialisiert ist return ram_rdbyte(sysmod,RAMDRV) PUB rd_newfile(stradr,len) | adr1,adr2,i,char,nx 'ramdisk: neue datei erzeugen ' ' dpos --> 4 byte - (zeiger auf next eintrag) ' 4 byte - dateilänge ' 12 byte - name 8+3 ' len byte - daten if ram_rdbyte(sysmod,RAMDRV) 'zeiger auf header der letzten datei setzen adr1 := 0 repeat nx := ram_rdlong(sysmod,adr1) if nx adr1 := nx until nx == 0 'letzter zeiger ist 0 'header der neuen datei setzen adr2 := adr1 + ram_rdlong(sysmod,adr1+4) + RDHLEN 'startadresse der neuen datei ram_wrlong(sysmod,0,adr2) 'neuer zeiger wird nun 0 (letzte datei) ram_wrlong(sysmod,len,adr2+4) 'länge der datei 'dateinamen setzen i := adr2 + 8 repeat 12 'alle zeichen löschen ram_wrbyte(sysmod," ",i++) i := 0 repeat 12 'string mit namen übertragen char := byte[stradr+i] ifnot char quit ram_wrbyte(sysmod,char,adr2+8+i++) 'rbas hinter neue datei setzen ram_setbas(adr2 + RDHLEN + len) 'pointer in vorigem header setzen ram_wrlong(sysmod,adr2,adr1) PUB rd_init|i,j 'ramdisk: system initialisieren ifnot ram_rdbyte(sysmod,RAMDRV) i := STARTRD ram_wrlong(sysmod,0,i) 'zeiger schreiben (letzter zeiger ist 0) i += 4 ram_wrlong(sysmod,1,i) 'dateilänge schreiben i += 4 repeat j from 0 to 11 'namen schreiben ram_wrbyte(sysmod,byte[@rdinit+j],i++) ram_wrbyte(sysmod,0,i++) '1 datenbyte ram_setbas(i) 'neue basis für userbereich setzen ram_wrbyte(sysmod,1,RAMDRV) 'globales Flag setzen 'ftab löschen i := 0 repeat files * FTCNT ftab[i++] := -1 ftab[0] := ram_getbas 'erster eintrag ist userram ftab[1] := ram_getend ftab[2] := 0 PUB rd_del(stradr):adr | d,s,nx,len,blk 'ramdisk: datei löschen 'grösse berechnen if (adr := rd_searchadr(stradr)) > 0 len := ram_rdlong(sysmod, adr+4) + RDHLEN nx := ram_rdlong(sysmod,adr) blk := ram_getbas - nx 'block löschen d := adr s := adr + len repeat blk ram_wrbyte(sysmod,ram_rdbyte(sysmod,s++),d++) 'header neu setzen repeat nx := ram_rdlong(sysmod,adr) if nx nx := nx - len ram_wrlong(sysmod,nx,adr) adr := nx until nx == 0 'fbas neu setzen ram_setbas(ram_getbas - blk) return adr PUB rd_rename(stradr1,stradr2): err | i,adr,char 'ramdisk: datei umbenennen err := 0 'datei suchen, adresse ermitteln ifnot adr := rd_searchadr(stradr1) return 5 'neuen namen setzen i := adr + 8 repeat 12 'alle zeichen löschen ram_wrbyte(sysmod," ",i++) i := 0 repeat 12 'string mit namen übertragen char := byte[stradr2+i] ifnot char quit ram_wrbyte(sysmod,char,adr+8+i++) PUB rd_searchdat(stradr):adr 'ramdisk: name --> adresse daten if (adr := rd_searchadr(stradr)) return adr + RDHLEN PUB rd_searchadr(stradr):adr | hp,nx,i,j,c 'ramdisk: name --> adresse header ' adr = 0 name nicht gefunden ' adr > 0 adresse des headers hp := STARTRD adr := STARTRD repeat nx := ram_rdlong(sysmod,hp) 'string kopieren i := 0 j := hp + 8 repeat c := ram_rdbyte(sysmod,j+i) if c == " " c := 0 dstr[i++] := c until (i == 12) OR (c == " ") dstr[i] := 0 'string vergleichen if strcomp(stradr,@dstr) adr := hp hp := nx until (nx == 0) OR (adr > 0) dpos := adr return adr PUB rd_get(fnr): wert | adr,fix 'ramdisk: nächstes byte aus datei lesen fix := fnr * FTCNT adr := ftab[fix+0] + ftab[fix+2] wert := ram_rdbyte(sysmod,adr) rd_seek(fnr,ftab[fix+2]+1) PUB rd_put(fnr,wert) | adr,fix 'ramdisk: nächstes byte in datei schreiben fix := fnr * FTCNT adr := ftab[fix+0] + ftab[fix+2] ram_wrbyte(sysmod,wert,adr) rd_seek(fnr,ftab[fix+2]+1) PUB rd_seek(fnr,fpos) | len,fix 'ramdisk: position in datei setzen fix := fnr * FTCNT len := ftab[fix+1] - ftab[fix] if (fpos => 0) AND (fpos =< len) ftab[fix+2] := fpos 'ramdisk: position in datei setzen PUB rd_rdbyte(fnr,adr):wert | fix 'ramdisk: byte aus datei lesen fix := fnr * FTCNT adr := ftab[fix]+adr if (adr =< ftab[fix+1]) wert := ram_rdbyte(sysmod,adr) PUB rd_wrbyte(fnr,wert,adr) | fix 'ramdisk: byte in datei schreiben fix := fnr * FTCNT adr := ftab[fix]+adr if (adr =< ftab[fix+1]) ram_wrbyte(sysmod,wert,adr) PUB rd_len(fnr): len | fix 'ramdisk: dateilänge einer geöffgneten datei abfragen fix := fnr * FTCNT len := ftab[fix+1] - ftab[fix+0] + 1 PUB rd_dlen: len 'ramdisk: verzeichnis dateilänge abfragen len := ram_rdlong(sysmod,dpos+4) PUB rd_dir 'ramdisk: verzeichnis öffnen dpos := STARTRD PUB rd_next:stradr | i,j 'ramdisk: verzeichniseintrag lesen 'ende erreicht? if dpos == TRUE return 0 'namen kopieren i := 0 j := dpos + 8 repeat 12 dstr[i] := ram_rdbyte(sysmod,j+i) i++ byte[@dstr+i] := 0 'zeiger auf nächste datei setzen dpos := ram_rdlong(sysmod,dpos) if dpos == 0 dpos := TRUE 'nächster eintrag ungültig return @dstr 'gültiger name PUB absadr(usradr): sysadr 'ramdisk: wandelt usermode-adr --> absolutadr sysadr := usradr - rbas PUB ram_getbas: adr 'ramdisk: virtuelle basisadresse abfragen 'return rbas return ram_rdlong(sysmod,RAMBAS) PUB ram_getend: adr 'ramdisk: endadresse abfragen 'return rend return ram_rdlong(sysmod,RAMEND) PUB ram_setbas(adr) 'ramdisk: virtuelle basisadresse setzen ram_wrlong(sysmod,adr,RAMBAS) rbas := adr ftab[0] := adr 'erster eintrag ist userram ftab[1] := SYSVAR - adr PUB ram_rdbyte(sys,adresse):wert 'eram: liest ein byte vom eram {{ram_rdbyte(adresse):wert - eram: ein byte aus externem ram lesen}} 'rambank 1 000000 - 07FFFF 'rambank 2 080000 - 0FFFFF 'sys = 0 - systemmodus, keine virtualisierung 'sys = 1 - usermodus, virtualisierte adresse 'sysmodus: der gesamte speicher (2 x 512 KB) werden durchgängig adressiert 'usermodus: adresse 0 = rambas ' adresse max = ramend if sys 'usermodus? adresse += rbas 'adresse virtualisieren if adresse > rend 'adressbereich überschritten? return 0 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_wrbyte(sys,wert,adresse) 'eram: schreibt ein byte in eram {{ram_wrbyte(wert,adresse) - eram: ein byte in externen ram schreiben}} 'rambank 1 000000 - 07FFFF 'rambank 2 080000 - 08FFFF 'sys = 0 - systemmodus, keine virtualisierung 'sys = 1 - usermodus, virtualisierte adresse 'sysmodus: der gesamte speicher (2 x 512 KB) werden durchgängig adressiert 'usermodus: adresse 0 = rambas ' adresse max = ramend ' if sys 'usermodus? adresse += rbas 'adresse virtualisieren if adresse > rend 'adressbereich überschritten? return 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 ram_rdlong(sys,eadr): wert 'eram: liest long ab eadr {{ram_rdlong - eram: liest long ab eadr}} 'sys = 0 - systemmodus, keine virtualisierung 'sys = 1 - usermodus, virtualisierte adresse wert := ram_rdbyte(sys,eadr) wert += ram_rdbyte(sys,eadr + 1) << 8 wert += ram_rdbyte(sys,eadr + 2) << 16 wert += ram_rdbyte(sys,eadr + 3) << 24 PUB ram_rdword(sys,eadr): wert 'eram: liest word ab eadr {{ram_rdlong(eadr):wert - eram: liest word ab eadr}} 'sys = 0 - systemmodus, keine virtualisierung 'sys = 1 - usermodus, virtualisierte adresse wert := ram_rdbyte(sys,eadr) wert += ram_rdbyte(sys,eadr + 1) << 8 PUB ram_wrlong(sys,wert,eadr) | n 'eram: schreibt long ab eadr {{ram_wrlong(wert,eadr) - eram: schreibt long ab eadr}} 'sys = 0 - systemmodus, keine virtualisierung 'sys = 1 - usermodus, virtualisierte adresse n := wert & $FF ram_wrbyte(sys,n,eadr) n := (wert >> 8) & $FF ram_wrbyte(sys,n,eadr + 1) n := (wert >> 16) & $FF ram_wrbyte(sys,n,eadr + 2) n := (wert >> 24) & $FF ram_wrbyte(sys,n,eadr + 3) PUB ram_wrword(sys,wert,eadr) | n 'eram: schreibt word ab eadr {{wr_word(wert,eadr) - eram: schreibt word ab eadr}} 'sys = 0 - systemmodus, keine virtualisierung 'sys = 1 - usermodus, virtualisierte adresse n := wert & $FF ram_wrbyte(sys,n,eadr) n := (wert >> 8) & $FF ram_wrbyte(sys,n,eadr + 1) DAT org 0 ' ' Entry ' entry jmp entry 'just loops regsys byte "reg.sys",0 belsys byte "bel.sys",0 admsys byte "adm.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. │ └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ }}