1623 lines
135 KiB
Plaintext
1623 lines
135 KiB
Plaintext
{{
|
|
┌──────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
│ Autor: Ingo Kripahle │
|
|
│ Copyright (c) 2010 Ingo Kripahle │
|
|
│ See end of file for terms of use. │
|
|
│ Die Nutzungsbedingungen befinden sich am Ende der Datei │
|
|
└──────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
Informationen : hive-project.de
|
|
Kontakt : drohne235@googlemail.com
|
|
System : TriOS
|
|
Name : [I]nput-[O]utput-[S]ystem - System-API
|
|
Chip : Regnatix
|
|
Typ : Objekt
|
|
Version : 01
|
|
Subversion : 1
|
|
Funktion : System-API - Schnittstelle der Anwendungen zu allen Systemfunktionen
|
|
|
|
Regnatix
|
|
system : Systemübergreifende Routinen
|
|
loader : Routinen um BIN-Dateien zu laden
|
|
eram : Zugriff auf externen RAM
|
|
bus : Kommunikation zu Administra und Bellatrix
|
|
|
|
Administra
|
|
sd-card : FAT16 Dateisystem auf SD-Card
|
|
scr : Screeninterface
|
|
hss : Hydra-Soundsystem
|
|
sfx : Sound-FX
|
|
|
|
Bellatrix
|
|
key : Keyboardroutinen
|
|
screen : Bildschirmsteuerung
|
|
|
|
Komponenten : -
|
|
COG's : -
|
|
Logbuch :
|
|
|
|
13-03-2009-dr235 - string für parameterübergabe zwischen programmen im eram eingerichtet
|
|
19-11-2008-dr235 - erste version aus dem ispin-projekt extrahiert
|
|
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
|
|
|
|
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
|
|
|
|
'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
|
|
|
|
'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
|
|
|
|
|
|
' 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
|
|
byte dname[16] 'puffer für dateiname
|
|
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
|
|
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_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
|
|
''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) '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)
|
|
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 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 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)
|
|
|
|
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
|
|
|
|
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_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 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_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 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)
|
|
|
|
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 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. │
|
|
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
}}
|
|
|
|
|