{{ ┌──────────────────────────────────────────────────────────────────────────────────────────────────────┐ │ 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 26-03-2010-dr235 - errormeldungen entfernt (mount) 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 STRCOUNT = 64 'größe des stringpuffers ' ADMINISTRA-FUNKTIONEN -------------------------------------------------------------------------- 'chip-managment #92, AMGR_SETSOUND AMGR_GETSPEC AMGR_SETSYSSOUND AMGR_GETSOUNDSYS AMGR_ALOAD AMGR_GETCOGS AMGR_GETVER AMGR_REBOOT '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 '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 '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 ' +---------- ' | +------- 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 byte dname[16] 'puffer für dateiname byte vname[16] 'puffer für volumelabel byte strpuffer[STRCOUNT] 'stringpuffer byte parapos 'position im parameterstring PUB start: wflag | n 'system: ios initialisieren ''funktionsgruppe : system ''funktion : ios initialisieren ''eingabe : - ''ausgabe : wflag - 0: kaltstart '' : 1: warmstart ''busprotokoll : - bus_init 'bus initialisieren sddmact(DM_USER) 'wieder in userverzeichnis wechseln lflagadr := rd_long(LOADERPTR) 'adresse der loader-register setzen if ram_read(MAGIC) == 235 return 1 else ram_write(235,MAGIC) return 0 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 belload(@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_write(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_write(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_read(PARAM+parapos) <> 0 'stringende? repeat until ram_read(PARAM+parapos) > CHAR_SPACE 'führende leerzeichen ausblenden parapos++ i := 0 repeat 'parameter kopieren c := ram_read(PARAM + parapos++) 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 {{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 OBJ '' A D M I N I S T R A CON ''------------------------------------------------- CHIP-MANAGMENT PUB admsetsound(sndfunktion):sndstat 'chip-mgr: soundsubsysteme verwalten bus_putchar1(AMGR_SETSOUND) bus_putchar1(sndfunktion) sndstat := bus_getchar1 PUB admsetsyssnd(status) 'chip-mgr: systemklänge ein/ausschalten bus_putchar1(AMGR_SETSYSSOUND) bus_putchar1(status) PUB admgetsndsys: status 'chip-mgr: status des soundsystems abfragen bus_putchar1(AMGR_GETSOUNDSYS) status := bus_getchar1 PUB admload(stradr) 'chip-mgr: neuen administra-code booten bus_putchar1(AMGR_ALOAD) bus_putstr1(stradr) PUB admgetver:ver 'chip-mgr: version abfragen bus_putchar1(AMGR_GETVER) ver := bus_getlong1 PUB admgetspec:spec 'chip-mgr: spezifikation abfragen bus_putchar1(AMGR_GETSPEC) spec := bus_getlong1 PUB admgetcogs:admcogs 'chip-mgr: verwendete cogs abfragen bus_putchar1(AMGR_GETCOGS) admcogs := bus_getchar1 PUB admreset 'chip-mgr: administra reset bus_putchar1(AMGR_REBOOT) CON ''------------------------------------------------- SD_LAUFWERKSFUNKTIONEN PUB sdmount: err 'sd-card: mounten {{sdmount - sd-card: mounten}} bus_putchar1(SD_MOUNT) err := bus_getchar1 PUB sddir 'sd-card: verzeichnis wird geöffnet {{sddir - sd-card: directory wird geöffnet}} bus_putchar1(SD_DIROPEN) PUB sdnext: stradr | flag '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 if flag return bus_getstr1 else return 0 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 sdclose:err 'sd-card: datei schließen {{sdclose - sd-card: datei schließen}} bus_putchar1(SD_CLOSE) 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 sdgetblk(count,bufadr) | i 'sd-card: block lesen 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 i := 0 bus_putchar1(SD_PUTBLK) bus_putlong1(count) repeat count bus_putchar1(byte[bufadr][i++]) 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(anr): attrib 'sd-card: dateiattribute abfragen '' : 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 bus_putchar1(SD_FATTRIB) bus_putchar1(anr) attrib := bus_getlong1 PUB sdvolname: stradr | len,i 'sd-card: volumelabel abfragen bus_putchar1(SD_VOLNAME) 'kommando: volumelabel abfragen len := bus_getchar1 'längenbyte empfangen repeat i from 0 to len - 1 'string empfangen vname[i] := bus_getchar1 vname[i] := 0 'string abschließen return @vname 'sonst stringzeiger PUB sdcheckmounted: flag 'sd-card: test ob volume gemounted ist bus_putchar1(SD_CHECKMOUNTED) return bus_getchar1 PUB sdcheckopen: flag 'sd-card: test ob datei geöffnet ist bus_putchar1(SD_CHECKOPEN) return bus_getchar1 PUB sdcheckused 'sd-card: abfrage der benutzten sektoren bus_putchar1(SD_CHECKUSED) return bus_getlong1 PUB sdcheckfree 'sd_card: abfrage der freien sektoren bus_putchar1(SD_CHECKFREE) return bus_getlong1 PUB sdnewfile(stradr):err 'sd_card: neue datei erzeugen bus_putchar1(SD_NEWFILE) bus_putstr1(stradr) err := bus_getchar1 PUB sdnewdir(stradr):err 'sd_card: neues verzeichnis erzeugen bus_putchar1(SD_NEWDIR) bus_putstr1(stradr) err := bus_getchar1 PUB sddel(stradr):err 'sd_card: datei/verzeichnis löschen bus_putchar1(SD_DEL) bus_putstr1(stradr) err := bus_getchar1 PUB sdrename(stradr1,stradr2):err 'sd_card: datei/verzeichnis umbenennen bus_putchar1(SD_RENAME) bus_putstr1(stradr1) bus_putstr1(stradr2) err := bus_getchar1 PUB sdchattrib(stradr1,stradr2):err 'sd-card: attribute ändern bus_putchar1(SD_CHATTRIB) bus_putstr1(stradr1) bus_putstr1(stradr2) err := bus_getchar1 PUB sdchdir(stradr):err 'sd-card: verzeichnis wechseln bus_putchar1(SD_CHDIR) bus_putstr1(stradr) err := bus_getchar1 PUB sdformat(stradr):err 'sd-card: medium formatieren bus_putchar1(SD_FORMAT) bus_putstr1(stradr) err := bus_getchar1 PUB sdunmount:err 'sd-card: medium abmelden bus_putchar1(SD_UNMOUNT) err := bus_getchar1 PUB sddmact(marker):err 'sd-card: dir-marker aktivieren bus_putchar1(SD_DMACT) bus_putchar1(marker) err := bus_getchar1 PUB sddmset(marker) 'sd-card: dir-marker setzen bus_putchar1(SD_DMSET) bus_putchar1(marker) PUB sddmget(marker):status 'sd-card: dir-marker abfragen bus_putchar1(SD_DMGET) bus_putchar1(marker) status := bus_getlong1 PUB sddmclr(marker) 'sd-card: dir-marker löschen bus_putchar1(SD_DMCLR) bus_putchar1(marker) CON ''------------------------------------------------- Hydra Sound System 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_setslot2(adr,slot) | i,n 'sfx: sendet sfx-daten (hub-ram) in sfx-slot 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 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 bus_putchar1(SDW_START) bus_putstr1(stradr) status := bus_getchar1 PUB wav_stop:status 'sdw: wave-wiedergabe beenden bus_putchar1(SDW_STOP) status := bus_getchar1 PUB wav_status: status 'sdw: status des players abfragen bus_putchar1(SDW_STATUS) status := bus_getchar1 PUB wav_lvol(vol) 'sdw: linke lautstärke einstellen bus_putchar1(SDW_LVOL) bus_putchar1(vol) PUB wav_rvol(vol) 'sdw: rechte lautstärke einstellen bus_putchar1(SDW_RVOL) bus_putchar1(vol) OBJ '' B E L L A T R I X CON ''------------------------------------------------- CHIP-MANAGMENT PUB belgetver:ver 'chip-mgr: version abfragen ver := 0 PUB belgetspec:spec 'chip-mgr: spezifikationen abfragen spec := 0 PUB belgetcogs:belcogs 'chip-mgr: verwendete cogs abfragen bus_putchar2($0) 'kommandosequenz einleiten bus_putchar2($5) 'code 5 = freie cogs belcogs := bus_getchar2 'statuswert empfangen PUB belreset 'chip-mgr: bellatrix reset {{breset - bellatrix neu starten}} bus_putchar2($0) 'kommandosequenz einleiten bus_putchar2(99) '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 ' 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 waitcnt(cnt + 200_000_000) 'warte bis bel fertig ist 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_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 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 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) OBJ '' R E G N A T I X CON '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 }} 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 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 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) DAT org ' ' 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. │ └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ }}