{{ ┌──────────────────────────────────────────────────────────────────────────────────────────────────────┐ │ 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 #93, AMGR_GETSPEC AMGR_SETSYSSOUND AMGR_GETSOUNDSYS AMGR_ALOAD AMGR_GETCOGS AMGR_GETVER AMGR_REBOOT '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 '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 byte cog[8] byte cogs PUB start: wflag | n 'system: initialisiert system {{start - initialisiert das grundsystem wflag == 1 --> warmstart}} bus_init 'bus initialisieren sddmact(DM_USER) 'wieder in userverzeichnis wechseln lflagadr := rd_long(LOADERPTR) 'adresse der loader-register setzen n := ram_read(MAGIC) if n <> 235 ram_write(235,MAGIC) 'warmstartflag return 0 elseif n == 235 return 1 PUB startram 'system: initialisierung des systems bei ram-upload {{startram - wenn man zu testzwecken das programm direkt in den ram überträgt und startet, bekommen alle Props ein reset, wodurch bellatrix auf einen treiber wartet. für testzwecke erledigt diese routine den upload des standard-vga-treibers. wird aus dem programm später eine bin-datei generiert, welche über den loader gestartet wird sollte diese routine auskommentiert werden.}} waitcnt(cnt + 50_000_000) 'warte auf administra sdmount 'sd-karte mounten bload(string("bel.sys")) 'vga-treiber zu bellatrix übertragen waitcnt(cnt + 50_000_000) 'warte bis treiber initialisiert ist PUB paraset(stradr) | i,c 'system: parameterbereich beschreiben {{paraset(stradr) - system: ein 0-term-string wird von stradr in den parameterbereich kopiert}} paradel repeat i from 0 to 63 ' puffer ist mx. 64 zeichen lang c := byte[stradr+i] ram_write(c,PARAM+i) if c == 0 'bei stringende vorzeitig beenden return PUB parastart 'system: setzt den zeiger auf parameteranfangsposition {{parastart - setzt den zeiger auf parameteranfangsposition}} parapos := 0 PUB paradel | i 'system: parameterbereich löschen {{paradel - system: parameterbereich löschen}} repeat i from 0 to 63 ram_write(0,PARAM+i) PUB paranext(stradr): err | i,c 'system: überträgt den nächsten parameter in stringdatei {{paranext(stradr) - system: überträgt den nächsten parameter in stringdatei rückgabewert 0 --> kein weiterer parameter >0 --> parameter gültig}} if ram_read(PARAM+parapos) <> 0 'stringende? repeat until ram_read(PARAM+parapos) > CHAR_SPACE 'führende leerzeichen ausblenden parapos++ i := 0 repeat 'nächsten string kopieren c := ram_read(PARAM + parapos) byte[stradr + i] := c parapos++ i++ byte[stradr + i] := 0 'string abschließen until (c == CHAR_SPACE) or (c == 0) return 1 else return 0 PUB bload(stradr) | n,rc,ii,plen 'system: bellatrix mit grafiktreiber initialisieren {{bload(stradr) - bellatrix mit grafiktreiber initialisieren stradr - adresse eines 0-term-strings mit dem dateinamen des bellatrixtreibers }} ' kopf der bin-datei einlesen ------------------------------------------------------ rc := sdopen("r",stradr) 'datei öffnen repeat ii from 0 to 15 '16 bytes header --> bellatrix n := sdgetc bus_putchar2(n) sdclose 'bin-datei schießen ' objektgröße empfangen plen := bus_getchar2 << 8 'hsb empfangen plen := plen + bus_getchar2 'lsb empfangen ' bin-datei einlesen ------------------------------------------------------ sdopen("r",stradr) 'bin-datei öffnen repeat ii from 0 to plen-1 'datei --> bellatrix n := sdgetc bus_putchar2(n) sdclose PUB reggetcogs:regcogs |i,c 'system: fragt freie cogs von regnatix ab {{ fragt freie cogs ab }} 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 {{stop - beendet anwendung und startet os}} sddmact(DM_ROOT) ldbin(@sysbin) PUB ldsys 'loader: startet systemdatei {{ldsys - loader: startet sys.bin}} sddmact(DM_ROOT) ldbin(@sysbin) PUB ldbin(stradr) | len,i,stradr1,stradr2 'loader: startet bin-datei über loader {{ldbin - loader: startet bin-datei über loader}} len := strsize(stradr) stradr2 := lflagadr + 1 repeat i from 0 to len - 1 'string in loadervariable kopieren byte[stradr2][i] := byte[stradr][i] byte[stradr2][++i] := 0 'string abschließen byte[lflagadr][0] := 1 'loader starten CON '' A D M I N I S T R A CON ''------------------------------------------------- CHIP-MANAGMENT 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 'sdw: wave-wiedergabe beenden bus_putchar1(SDW_STOP) PUB wav_status: status 'sdw: status des players abfragen bus_putchar1(SDW_STATUS) status := bus_getchar1 CON '' B E L L A T R I X CON ''------------------------------------------------- CHIP-MANAGMENT PUB belgetver:ver ver := 0 PUB belgetspec:spec spec := 0 PUB belgetcogs:belcogs bus_putchar2($0) 'kommandosequenz einleiten bus_putchar2($5) 'code 5 = freie cogs belcogs := bus_getchar2 'statuswert empfangen PUB belreset 'system: bellatrix neu starten {{breset - bellatrix neu starten}} bus_putchar2($0) 'kommandosequenz einleiten bus_putchar2(99) 'code 99 = reboot PUB belload(stradr) belreset 'bellatrix neu starten waitcnt(cnt + 200_000_000) 'warte bis bel fertig ist bload(stradr) 'treiberupload 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) CON '' 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 sysbin byte "reg.sys",0 {{ ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ │ TERMS OF USE: MIT License │ ├──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤ │Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation │ │files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, │ │modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software│ │is furnished to do so, subject to the following conditions: │ │ │ │The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.│ │ │ │THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE │ │WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR │ │COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, │ │ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. │ └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ }}