721 lines
74 KiB
Plaintext
721 lines
74 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 : Administra-Flash
|
|
Chip : Administra
|
|
Typ : Flash
|
|
Version : 01
|
|
Subversion : 1
|
|
Funktion : Dieser Code wird von Administra nach einem Reset aus dem EEProm in den hRAM kopiert
|
|
und startet. Im Gegensatz zu Bellatrix und Regnatix, die einen Loader aus dem EEProm
|
|
laden und entsprechende Systemdateien vom SD-Cardlaufwerk booten, also im
|
|
wesentlichen vor dem Bootvorgang keine weiter Funktionalität als die Ladeprozedur
|
|
besitzen, muß das EEProm-Bios von Administra mindestens die Funktionalität des
|
|
SD-Cardlaufwerkes zur Verfügung stellen können. Es erscheint deshalb sinnvoll, dieses
|
|
BIOS gleich mit einem ausgewogenen Funktionsumfang auszustatten, welcher alle Funktionen
|
|
für das System bietet. Durch eine Bootoption kann dieses BIOS aber zur Laufzeit
|
|
ausgetauscht werden, um das Funktionssetup an konkrete Anforderungen anzupassen.
|
|
Komponenten : HSS 1.2 Andrew Arsenault Lizenz unklar
|
|
FSRW 1.6 Radical Eye Software MIT Lizenz
|
|
SDSPIQASM Radical Eye Software MIT Lizenz
|
|
ASM WAV Player 1b Raymond Allen MIT Lizenz
|
|
|
|
COG's : MANAGMENT 1 COG
|
|
FSRW/SDSPI 1 COG
|
|
HSS 2 COG's
|
|
WAV 1 COG
|
|
-------------------
|
|
3 oder 4 Cogs
|
|
- WAV und HSS werden alternativ verwendet!
|
|
Logbuch :
|
|
|
|
14-11-2008-dr235 - erste version erstellt
|
|
13-03-2009-dr235 - sd_eof eingefügt
|
|
25-01-2009-dr235 - komfortableres interface für hss-player eingefügt
|
|
19-03-2009-dr235 - seek, ftime, fattrib und fsize eingefügt
|
|
22-08-2009-dr235 - getcogs eingefügt
|
|
09-01-2010-dr235 - fehler in sfx_fire korrigiert
|
|
10-01-2010-dr235 - fehler in sdw_stop - hss wurde nicht wieder gestartet
|
|
15-03-2010-dr235 - start trios
|
|
21-03-2010-dr235 - screeninterface entfernt
|
|
|
|
Kommandoliste :
|
|
|
|
#1 err.b> sd.mount - medium mounten
|
|
#2 sd.dir - verzeichnis öffnen
|
|
#3 0> len.b> name.b> sd.next - nächster eintrag im verzeichnis
|
|
1> - kein weiterer dateiname
|
|
#4 >modus.b >len.b >name.s err.b> sd.open - datei öffnen
|
|
#5 err.b> sd.close - datei schließen
|
|
#6 daten.b> sd.getc - zeichen lesen
|
|
#7 >daten.b sd.putc - zeichen schreiben
|
|
#8 >len.b sd.getblk - block lesen
|
|
#9 >len.b sd.putblk - block schreiben
|
|
|
|
|
|
#100 >len.b >name.b err.b> hss.load - hss-datei in player laden
|
|
#101 hss.play - musikdatei abspielen
|
|
#102 hss.stop - musikwiedergabe beenden
|
|
#103 hss.pause - musikwiedergabe pausieren
|
|
#104 >1-byte-regnr 4-byte-regwert> hss.peek - register des players lesen
|
|
#105 >1-byte-regnr 2-byte-regwert> hss.intreg - interfaceregister auslesen
|
|
#106 >1-byte-vol hss.vol - volume einstellen 0..15
|
|
#107 >1-byte-slotnr >1-byte-channel - sfx in slotpuffer abspielen
|
|
#108 >1-byte-slotnr >32-byte-sfxdaten - schreibt 32 byte slotpufferdaten
|
|
#109 - sfx keyoff
|
|
|
|
Notizen :
|
|
|
|
Was fehlt noch:
|
|
- Umwandlung und Verwaltung der speziellen Puffer in einen universellen Heap
|
|
|
|
}}
|
|
|
|
|
|
CON
|
|
|
|
_CLKMODE = XTAL1 + PLL16X
|
|
_XINFREQ = 5_000_000
|
|
|
|
'signaldefinitionen administra
|
|
|
|
#0, D0,D1,D2,D3,D4,D5,D6,D7 'datenbus
|
|
#8, ADM_SOUNDL,ADM_SOUNDR 'sound (stereo 2 pin)
|
|
#10, ADM_SDD0,ADM_SDCLK,ADM_SDCMD,ADM_SDD3 'sd-cardreader (4 pin)
|
|
#23, ADM_SELECT 'administra-auswahlsignal
|
|
#24, HBEAT 'front-led
|
|
BUSCLK 'bustakt
|
|
BUS_WR '/wr - schreibsignal
|
|
BUS_HS ' '/hs - quittungssignal
|
|
|
|
VER_H = 0
|
|
VER_L = 1
|
|
VER_S = 1 'subversion "wave"
|
|
|
|
'
|
|
' hbeat --------+
|
|
' clk -------+|
|
|
' /wr ------+||
|
|
' /hs -----+||| +------------------------- /cs
|
|
' |||| | +------+ d0..d7
|
|
' |||| | | |
|
|
DB_IN = %00001001_00000000_00000000_00000000 'dira-wert für datenbuseingabe
|
|
DB_OUT = %00001001_00000000_00000000_11111111 'dira-wert für datenbusausgabe
|
|
|
|
M1 = %00000010_00000000_00000000_00000000 'busclk=1? & /prop1=0?
|
|
M2 = %00000010_10000000_00000000_00000000 'maske: busclk & /cs (/prop1)
|
|
|
|
M3 = %00000000_00000000_00000000_00000000 'busclk=0?
|
|
M4 = %00000010_00000000_00000000_00000000 'maske: busclk
|
|
|
|
LED_OPEN = HBEAT 'led-pin für anzeige "dateioperation"
|
|
SD_BASE = ADM_SDD0 'baspin cardreader
|
|
CNT_HBEAT = 5_000_0000 'blinkgeschw. front-led
|
|
|
|
MPLEN = 16384 'größe des musikpuffers
|
|
|
|
SDWBUFSIZE = 100 'puffer für wav-player
|
|
|
|
OBJ
|
|
sdfat : "admflash-fsrw" 'sd-card fat16
|
|
hss : "admflash-hss" 'hydra-sound-system
|
|
wav : "admflash-wav" 'sd-wave
|
|
VAR
|
|
|
|
long stackhb[9] 'stack für hbeat-cog
|
|
byte tbuf[20] 'stringpuffer
|
|
byte bgmusic[MPLEN] 'hss-puffer
|
|
byte sfxdat[16 * 32] 'sfx-slotpuffer
|
|
byte fl_eof '1 = eof
|
|
byte fl_syssnd '1 = systemtöne an
|
|
byte st_sound '0 = aus, 1 = hss, 2 = wav
|
|
|
|
' variablen für sdwav-player
|
|
|
|
long sdwp1 'parameter für play-cog
|
|
long sdwp2 'müssen hintereinander liegen
|
|
long sdwp3
|
|
long sdwp4
|
|
long sdwbuff1[SDWBUFSIZE]
|
|
long sdwbuff2[SDWBUFSIZE]
|
|
long sdwstack[10]
|
|
byte sdwcog
|
|
byte sdwflag
|
|
byte sdwh[44]
|
|
|
|
CON ''------------------------------------------------- ADMINISTRA
|
|
|
|
PUB main | cmd 'chip: kommandointerpreter
|
|
''funktionsgruppe : chip
|
|
''funktion : kommandointerpreter
|
|
''eingabe : -
|
|
''ausgabe : -
|
|
|
|
init_chip 'bus/vga/keyboard/maus initialisieren
|
|
repeat
|
|
cmd := bus_getchar 'kommandocode empfangen
|
|
case cmd
|
|
0: !outa[LED_OPEN] 'led blinken
|
|
|
|
' ---------------------------------------------- SD-FUNKTIONEN
|
|
1: sd_mount 'sd-card mounten '
|
|
2: sd_opendir 'direktory öffnen
|
|
3: sd_nextfile 'verzeichniseintrag lesen
|
|
4: sd_open 'datei öffnen
|
|
5: sd_close 'datei schließen
|
|
6: sd_getc 'zeichen lesen
|
|
7: sd_putc 'zeichen schreiben
|
|
8: sd_getblk 'block lesen
|
|
9: sd_putblk 'block schreiben
|
|
10: sd_eof 'eof-flag abfragen
|
|
11: sd_seek 'zeiger in datei positionieren
|
|
12: sd_fattrib 'attribute übergeben
|
|
13: sd_ftime 'zeitstempel übergeben
|
|
14: sd_fsize 'dateigröße übergeben
|
|
|
|
' ---------------------------------------------- CHIP-MANAGMENT
|
|
90: mgr_setsyssound 'systemsound ein/ausschalten
|
|
91: mgr_getsoundsys 'abfrage welches soundsystem aktiv ist
|
|
92: mgr_starthss 'hss starten
|
|
93: mgr_stophss 'hss beenden
|
|
94: mgr_startwav 'wav-player starten
|
|
95: mgr_stopwav 'wav-player beenden
|
|
96: mgr_aload 'neues code booten
|
|
97: bus_putchar(getcogs) 'freie cogs abfragen
|
|
98: bus_putchar(VER_H) '98: codeversion abfragen
|
|
bus_putchar(VER_L)
|
|
bus_putchar(VER_S)
|
|
99: reboot '99: neu starten
|
|
|
|
' ---------------------------------------------- HSS-FUNKTIONEN
|
|
100: hss_load 'hss-datei in puffer laden
|
|
101: hss.hmus_load(@bgmusic) 'play
|
|
hss.hmus_play
|
|
102: hss.hmus_stop 'stop
|
|
103: hss.hmus_pause 'pause
|
|
104: hss_peek 'register lesen
|
|
105: hss_intreg 'interfaceregister auslesen
|
|
106: hss_vol 'lautstärke setzen
|
|
107: sfx_fire 'sfx abspielen
|
|
108: sfx_setslot 'sfx-slot setzen
|
|
109: sfx_keyoff
|
|
110: sfx_stop
|
|
|
|
' ---------------------------------------------- WAV-FUNKTIONEN
|
|
150: sdw_start 'spielt wav-datei direkt von sd-card ab
|
|
151: sdw_stop 'stopt wav-cog
|
|
152: sdw_status 'fragt status des players ab
|
|
|
|
PUB init_chip 'chip: initialisierung des administra-chips
|
|
''funktionsgruppe : chip
|
|
''funktion : - initialisierung des businterface
|
|
'' - grundzustand definieren (hss aktiv, systemklänge an)
|
|
''eingabe : -
|
|
''ausgabe : -
|
|
|
|
'businterface initialisieren
|
|
dira := db_in 'datenbus auf eingabe schalten
|
|
outa[bus_hs] := 1 'handshake inaktiv
|
|
'grundzustand herstellen (hss aktiv + systemklänge an)
|
|
hss.start 'soundsystem starten
|
|
fl_syssnd := 1 'systemsound an
|
|
|
|
PUB bus_putchar(zeichen) 'chip: ein byte über bus ausgeben
|
|
''funktionsgruppe : chip
|
|
''funktion : senderoutine für ein byte zu regnatix über den systembus
|
|
''eingabe : byte zeichen
|
|
''ausgabe : -
|
|
|
|
waitpeq(M1,M2,0) 'busclk=1? & /prop1=0?
|
|
dira := db_out 'datenbus auf ausgabe stellen
|
|
outa[7..0] := zeichen 'daten ausgeben
|
|
outa[bus_hs] := 0 'daten gültig
|
|
waitpeq(M3,M4,0) 'busclk=0?
|
|
outa[bus_hs] := 1 'daten ungültig
|
|
dira := db_in 'bus freigeben
|
|
|
|
PUB bus_getchar : zeichen 'chip: ein byte über bus empfangen
|
|
''funktionsgruppe : chip
|
|
''funktion : emfangsroutine für ein byte von regnatix über den systembus
|
|
''eingabe : -
|
|
''ausgabe : byte zeichen
|
|
|
|
waitpeq(M1,M2,0) 'busclk=1? & /prop1=0?
|
|
zeichen := ina[7..0] 'daten einlesen
|
|
outa[bus_hs] := 0 'daten quittieren
|
|
outa[bus_hs] := 1
|
|
waitpeq(M3,M4,0) 'busclk=0?
|
|
|
|
CON ''------------------------------------------------- SUBPROTOKOLLFUNKTIONEN
|
|
|
|
PUB sub_getstring | i,len 'sub: string einlesen
|
|
''funktionsgruppe : sub
|
|
''funktion : subprotokoll um einen string von regnatix zu empfangen und im
|
|
'' : textpuffer (tbuf) zu speichern
|
|
''eingabe : -
|
|
''ausgabe : -
|
|
''busprotokoll : [get.len][get.byte(1)]..[get.byte(len)]
|
|
'' : len - länge des dateinamens
|
|
|
|
repeat i from 0 to 19 'puffer löschen
|
|
tbuf[i] := 0
|
|
len := bus_getchar 'längenbyte name empfangen
|
|
repeat i from 0 to len - 1 'dateiname einlesen
|
|
tbuf[i] := bus_getchar
|
|
|
|
CON ''------------------------------------------------- CHIP-MANAGMENT
|
|
|
|
PUB mgr_setsyssound 'cmgr: systemsound ein/ausschalten
|
|
''funktionsgruppe : cmgr
|
|
''funktion : systemklänge steuern
|
|
''eingabe :
|
|
''ausgabe :
|
|
|
|
PUB mgr_getsoundsys 'cmgr: abfrage welches soundsystem aktiv ist
|
|
''funktionsgruppe : cmgr
|
|
''funktion : abfrage welches soundsystem aktiv ist
|
|
''eingabe :
|
|
''ausgabe :
|
|
|
|
PUB mgr_starthss 'cmgr: hss starten
|
|
''funktionsgruppe : cmgr
|
|
''funktion : hss-player starten
|
|
''eingabe :
|
|
''ausgabe :
|
|
|
|
PUB mgr_stophss 'cmgr: hss beenden
|
|
''funktionsgruppe : cmgr
|
|
''funktion : hss-player beenden
|
|
''eingabe :
|
|
''ausgabe :
|
|
|
|
PUB mgr_startwav 'cmgr: wav-player starten
|
|
''funktionsgruppe : cmgr
|
|
''funktion : wav-player starten
|
|
''eingabe :
|
|
''ausgabe :
|
|
|
|
PUB mgr_stopwav 'cmgr: wav-player beenden
|
|
''funktionsgruppe : cmgr
|
|
''funktion : wav-player beenden
|
|
''eingabe :
|
|
''ausgabe :
|
|
|
|
PUB mgr_aload 'cmgr: neues code booten
|
|
''funktionsgruppe : cmgr
|
|
''funktion : administra mit neuem code booten
|
|
''eingabe :
|
|
''ausgabe :
|
|
|
|
PUB getcogs: cogs |i,c,cog[8] 'cmgr: abfragen wie viele cogs in benutzung sind
|
|
''funktionsgruppe : cmgr
|
|
''funktion : abfrage wie viele cogs in benutzung sind
|
|
''eingabe : -
|
|
''ausgabe : cogs - anzahl der cogs
|
|
|
|
i :=0
|
|
cogs := 0
|
|
repeat 'loads as many cogs as possible and stores their cog numbers
|
|
c := cog[i] := cognew(@entry, 0)
|
|
if c=>0
|
|
i++
|
|
while c => 0
|
|
cogs := i
|
|
repeat 'unloads the cogs and updates the string
|
|
i--
|
|
if i=>0
|
|
cogstop(cog[i])
|
|
while i=>0
|
|
|
|
|
|
CON ''------------------------------------------------- SD-LAUFWERKSFUNKTIONEN
|
|
|
|
PUB sd_open | err,modus,len,i ''sd: datei öffnen
|
|
{{sd_open - sd: datei öffnen}}
|
|
modus := bus_getchar 'modus empfangen
|
|
len := bus_getchar 'längenbyte name empfangen
|
|
repeat i from 0 to len - 1 'dateiname einlesen
|
|
tbuf[i] := bus_getchar
|
|
err := sdfat.popen(@tbuf, modus) 'datei öffnen
|
|
if err == 0
|
|
if fl_syssnd == 1
|
|
hss.sfx_play(1, @SoundFX3) 'Heartbeat High
|
|
outa[LED_OPEN] := 1
|
|
if err <> 0
|
|
if fl_syssnd == 1
|
|
hss.sfx_play(1, @SoundFX1) 'Error
|
|
bus_putchar(err) 'ergebnis der operation senden
|
|
|
|
PUB sd_close | err ''sd: datei schließen
|
|
{{sd_close - sd: datei schließen}}
|
|
err := sdfat.pclose
|
|
if err == 0
|
|
outa[LED_OPEN] := 0
|
|
if fl_syssnd == 1
|
|
hss.sfx_play(1, @SoundFX4) 'Heartbeat Low
|
|
bus_putchar(err) 'ergebnis der operation senden
|
|
|
|
PUB sd_getc | n ''sd: zeichen aus datei lesen
|
|
{{sd_getc - sd: zeichen aus datei lesen}}
|
|
n := sdfat.pgetc
|
|
bus_putchar(n)
|
|
if n == -1
|
|
fl_eof := 1
|
|
else
|
|
fl_eof := 0
|
|
|
|
PUB sd_eof ''sd: abfragen ob eof erreicht ist
|
|
{{sd_eof - sd: abfragen ob eof erreicht ist}}
|
|
bus_putchar(fl_eof)
|
|
|
|
PUB sd_putc ''sd: zeichen in datei schreiben
|
|
{{sd_putc - sd: zeichen in datei schreiben}}
|
|
sdfat.pputc(bus_getchar)
|
|
|
|
PUB sd_getblk | len,i ''sd: block aus datei lesen
|
|
{{sd_getblk - sd: block aus datei lesen}}
|
|
len := bus_getchar 'niederwertiges byte empfangen
|
|
len += bus_getchar << 8 'höherwertiges byte empfangen
|
|
repeat i from 1 to len
|
|
bus_putchar(sdfat.pgetc)
|
|
|
|
|
|
PUB sd_putblk | len,i ''sd: block in datei schreiben
|
|
{{sd_putblk - sd: block in datei schreiben}}
|
|
len := bus_getchar
|
|
repeat i from 1 to len
|
|
sdfat.pputc(bus_getchar)
|
|
|
|
|
|
PUB sd_nextfile | flag,i,len ''sd: nächsten eintrag aus verzeichnis holen
|
|
{{sd_nextfile - sd: nächsten eintrag aus verzeichnis holen}}
|
|
flag := sdfat.nextfile(@tbuf) 'nächsten eintrag holen
|
|
bus_putchar(flag) 'status senden
|
|
len := strsize(@tbuf)
|
|
bus_putchar(len)
|
|
if flag == 0 'flag = 0 - eintrag gültig
|
|
repeat i from 0 to len - 1 'len byte dateinamen senden
|
|
bus_putchar(tbuf[i])
|
|
|
|
PUB sd_opendir ''sd: verzeichnis öffnen
|
|
{{sd_opendir - sd: verzeichnis öffnen}}
|
|
sdfat.opendir
|
|
if fl_syssnd == 1
|
|
hss.sfx_play(1, @SoundFX4) 'Heartbeat Low
|
|
|
|
PUB sd_mount | err ''sd: sd-card mounten
|
|
{{sd_mount - sd: sd-card mounten}}
|
|
err := sdfat.mount(SD_BASE) 'karte mounten
|
|
if err <> 0
|
|
if fl_syssnd == 1
|
|
hss.sfx_play(1, @SoundFX1) 'Play a sound effect on FX channel (1)
|
|
bus_putchar(err) 'fehlerstatus senden
|
|
|
|
PUB sd_seek | wert ''sd: zeiger in datei positionieren
|
|
'sd: zeiger in datei positionieren
|
|
wert := bus_getchar << 24 '32bit wert empfangen hsb/lsb
|
|
wert := wert + bus_getchar << 16
|
|
wert := wert + bus_getchar << 8
|
|
wert := wert + bus_getchar
|
|
sdfat.pseek(wert) 'byteposition
|
|
|
|
PUB sd_fattrib | wert ''sd: dateiattribute übergeben
|
|
'sd: dateiattribute übergeben
|
|
wert := sdfat.getfattrib
|
|
bus_putchar(wert) '1 byte
|
|
|
|
PUB sd_ftime | wert ''sd: zeitstempel übergeben
|
|
'sd: zeitstempel übergeben
|
|
wert := sdfat.getftime
|
|
bus_putchar(wert >> 24) '32bit wert senden hsb/lsb
|
|
bus_putchar(wert >> 16)
|
|
bus_putchar(wert >> 8)
|
|
bus_putchar(wert)
|
|
|
|
PUB sd_fsize | wert ''sd: dateigröße übergeben
|
|
'sd: dateigröße übergeben
|
|
wert := sdfat.getfsize
|
|
bus_putchar(wert >> 24) '32bit wert senden hsb/lsb
|
|
bus_putchar(wert >> 16)
|
|
bus_putchar(wert >> 8)
|
|
bus_putchar(wert)
|
|
|
|
|
|
|
|
CON ''------------------------------------------------- HSS-FUNKTIONEN
|
|
|
|
PUB sfx_fire | slot, chan, slotadr 'sfx: effekt im puffer abspielen
|
|
''funktionsgruppe : sfx
|
|
''funktion : effekt aus einem effektpuffer abspielen
|
|
''eingabe : -
|
|
''ausgabe : -
|
|
''busprotokoll : [107][get.slot][get.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 :)
|
|
|
|
slot := bus_getchar
|
|
chan := bus_getchar 'channelnummer lesen
|
|
if slot == $f0
|
|
hss.sfx_play(1, @SoundFX1) 'Play a sound effect on FX channel (1)
|
|
if slot == $f1
|
|
hss.sfx_play(1, @SoundFX2) 'Play a sound effect on FX channel (1)
|
|
if slot == $f2
|
|
hss.sfx_play(1, @SoundFX3) 'Play a sound effect on FX channel (1)
|
|
if slot == $f3
|
|
hss.sfx_play(1, @SoundFX4) 'Play a sound effect on FX channel (1)
|
|
if slot == $f4
|
|
hss.sfx_play(1, @SoundFX5) 'Play a sound effect on FX channel (1)
|
|
if slot == $f5
|
|
hss.sfx_play(1, @SoundFX6) 'Play a sound effect on FX channel (1)
|
|
if slot < $f0
|
|
slotadr := @sfxdat + (slot * 32) 'slotnummer lesen und adresse berechnen
|
|
hss.sfx_play(chan, slotadr)
|
|
|
|
PUB sfx_setslot | slotadr, i 'sfx: daten in sfx-slotpuffer schreiben
|
|
''funktionsgruppe : sfx
|
|
''funktion : die daten für ein sfx-slot werden werden von regnatix gesetzt
|
|
''eingabe : -
|
|
''ausgabe : -
|
|
''busprotokoll : [108][get.slot][32:get.daten]
|
|
'' : slot - $00..$0f nummer der freien effektpuffer
|
|
'' : daten - 32 byte effektdaten
|
|
|
|
slotadr := @sfxdat + (bus_getchar * 32) 'slotnummer lesen und adresse berechnen
|
|
repeat i from 0 to 31
|
|
byte[slotadr + i] := bus_getchar 'sfx-daten einlesen
|
|
|
|
PUB sfx_keyoff | chan 'sfx: release-phase einleiten um den effekt zu beenden
|
|
''funktionsgruppe : sfx
|
|
''funktion : für den aktuell abgespielten effekt wird die release-phase der
|
|
'' : adsr-hüllkurve eingeleitet, um ihn zu beenden
|
|
''eingabe : -
|
|
''ausgabe : -
|
|
''busprotokoll : [109][get.chan]
|
|
'' : chan - 0/1 stereokanal auf dem der effekt abgespielt werden soll
|
|
|
|
chan := bus_getchar 'channelnummer lesen
|
|
hss.sfx_keyoff(chan)
|
|
|
|
PUB sfx_stop | chan 'sfx: effekt sofort beenden
|
|
''funktionsgruppe : sfx
|
|
''funktion : der aktuell abgespielte effekt wird sofort beendet
|
|
''eingabe : -
|
|
''ausgabe : -
|
|
''busprotokoll : [110][get.chan]
|
|
'' : chan - 0/1 stereokanal auf dem der effekt abgespielt werden soll
|
|
|
|
chan := bus_getchar 'channelnummer lesen
|
|
hss.sfx_stop(chan)
|
|
|
|
PUB hss_vol 'hss: volume 0..15 einstellen
|
|
''funktionsgruppe : hss
|
|
''funktion : lautstärke des hss-players wird eingestellt
|
|
''eingabe : -
|
|
''ausgabe : -
|
|
''busprotokoll : [106][get.vol]
|
|
'' : vol - 0..15 gesamtlautstärke des hss-players
|
|
hss.hmus_vol(bus_getchar)
|
|
|
|
PUB hss_intreg | regnr,wert 'hss: auslesen der player-register
|
|
''funktionsgruppe : hss
|
|
''funktion : abfrage eines hss-playerregisters (16bit) durch regnatix
|
|
''eingabe : -
|
|
''ausgabe : -
|
|
''busprotokoll : [105][get.regnr][put.reghwt][put.regnwt]
|
|
'' : regnr - 0..24 (5 x 5 register)
|
|
'' : reghwt - höherwertiger teil des 16bit-registerwertes
|
|
'' : regnwt - niederwertiger teil des 16bit-registerwertes
|
|
|
|
regnr := bus_getchar 'registernummer einlesen
|
|
wert := hss.intread(regnr)
|
|
bus_putchar(wert >> 8) '16-bit-wert senden hsb/lsb
|
|
bus_putchar(wert)
|
|
|
|
PUB hss_peek | regnr,wert 'hss: zugriff auf alle internen playerregister
|
|
''funktionsgruppe : hss
|
|
''funktion : zugriff auf die internen playerregister; leider sind die register
|
|
'' : nicht dokumentiert; 48 long-register
|
|
''eingabe : -
|
|
''ausgabe : -
|
|
''busprotokoll : [104][get.regnr][put.regwert][put.regwert][put.regwert][put.regwert]
|
|
'' : regwert - long
|
|
|
|
regnr := bus_getchar 'registernummer einlesen
|
|
wert := hss.peek(regnr)
|
|
bus_putchar(wert >> 24) '32bit-registerwert senden hsb/lsb
|
|
bus_putchar(wert >> 16)
|
|
bus_putchar(wert >> 8)
|
|
bus_putchar(wert)
|
|
|
|
PUB hss_load | len,i,err 'hss: musikdatei in puffer laden
|
|
''funktionsgruppe : hss
|
|
''funktion : hss-datei wird in den modulpuffer geladen
|
|
''eingabe : -
|
|
''ausgabe : -
|
|
''busprotokoll : [100][sub.getstring][put.errnr]
|
|
|
|
sub_getstring 'dateinamen einlesen
|
|
err := sdfat.popen(@tbuf, "r") 'datei öffnen
|
|
bus_putchar(err) 'ergebnis der operation senden
|
|
if err == 0
|
|
outa[LED_OPEN] := 1
|
|
sdfat.pread(@bgmusic, MPLEN) 'datei laden
|
|
sdfat.pclose 'datei schließen
|
|
outa[LED_OPEN] := 0
|
|
|
|
|
|
CON ''------------------------------------------------- WAV-FUNKTIONEN
|
|
|
|
PUB sdw_play | err,srate,sam,n,j,w,fl_syssndback ''sdw: wav von sd-card abspielen
|
|
' - testcode!!!
|
|
' - sollte in einer extra cog laufen um nicht den interpreter zu blockieren
|
|
' - läuft leider nicht parallel zum hss!!!
|
|
|
|
hss.stop 'hss stopen da sie sich sonst stören
|
|
fl_syssndback := fl_syssnd 'status der systemsounds merken
|
|
fl_syssnd := 0 'sytemsound aus
|
|
|
|
sdwflag := 1
|
|
outa[LED_OPEN] := 1
|
|
err := sdfat.pread(@sdwh, 44) 'headerdaten einlesen
|
|
srate := sdwh[27]<<24+sdwh[26]<<16+sdwh[25]<<8+sdwh[24] 'samplerate auslesen
|
|
sam := sdwh[43]<<24+sdwh[42]<<16+sdwh[41]<<8+sdwh[40] 'samples auslesen
|
|
sam := sam >> 2
|
|
sdwp1 := @sdwbuff1[0]
|
|
sdwp2 := @sdwbuff2[0]
|
|
sdwp3 := (80_000_000)/(srate) '#clocks between samples'1814'for 44100ksps, 5000 'for 16ksps
|
|
sdwp4 := sam
|
|
wav.start(@sdwp1) 'wavcog starten
|
|
w := 0
|
|
n:=SDWBUFSIZE-1 'nummer des letzten indexelements im puffer
|
|
j:=SDWBUFSIZE*4 'number of bytes to read
|
|
repeat while (j==SDWBUFSIZE*4) 'schleife bis unvollständiger puffer gelesen wurde (eof)
|
|
|
|
if (sdwbuff1[n]==0) and w == 0
|
|
j:=sdfat.pread(@sdwbuff1, SDWBUFSIZE*4) 'read data words to input stereo buffer
|
|
'if(sdwbuff1[n]==0)
|
|
' sdwbuff1[n]:=1
|
|
outa[LED_OPEN] := 1
|
|
w := 1
|
|
|
|
if (sdwbuff2[n]==0) and w == 1
|
|
j:=sdfat.pread(@sdwbuff2, SDWBUFSIZE*4) 'read data words to input stereo buffer
|
|
'if (sdwbuff2[n]==0)
|
|
' sdwbuff2[n]:=1
|
|
outa[LED_OPEN] := 0
|
|
w := 0
|
|
|
|
wav.stop 'wavcog stopen
|
|
sdfat.pclose 'datei schließen
|
|
hss.start 'hss wieder starten
|
|
fl_syssnd := fl_syssndback 'status systemsound wiederherstellen
|
|
outa[LED_OPEN] := 0
|
|
sdwflag := 0 'status des players auf inaktiv setzen
|
|
repeat
|
|
|
|
PUB sdw_start | len,j,err ''sdw: startet extra cog mit sdwav-engine
|
|
|
|
sdw_stop 'ein evtl. noch laufenden player stopen
|
|
len := bus_getchar 'längenbyte name empfangen
|
|
repeat j from 0 to len - 1 'dateiname einlesen
|
|
tbuf[j] := bus_getchar
|
|
sdfat.mount(SD_BASE)
|
|
err := sdfat.popen(@tbuf, "r") 'datei öffnen
|
|
bus_putchar(err) 'ergebnis der operation senden
|
|
if err == 0
|
|
sdwcog := cognew(sdw_play,@sdwstack) + 1 'cog mit wavplayer starten
|
|
|
|
PUB sdw_stop | fl_syssndback ''sdw: stopt cog mit sdwav-engine
|
|
wav.stop 'wavcog stopen
|
|
if sdwcog
|
|
cogstop(sdwcog~ - 1) 'player stopen
|
|
sdwflag := 0 'status des players auf inaktiv setzen
|
|
outa[LED_OPEN] := 0
|
|
fl_syssnd := fl_syssndback 'systemsound evtl. wieder einschlten
|
|
hss.start 'hss wieder starten
|
|
|
|
PUB sdw_status ''sdw: sendet status des wav-players
|
|
bus_putchar(sdwflag)
|
|
|
|
|
|
|
|
DAT 'dummyroutine für getcogs
|
|
org
|
|
'
|
|
' Entry: dummy-assemblercode fuer cogtest
|
|
'
|
|
entry jmp entry 'just loops
|
|
|
|
|
|
|
|
DAT 'feste sfx-slots
|
|
|
|
'Wav 'Len 'Fre 'Vol 'LFO 'LFW 'FMa 'AMa
|
|
SoundFX1 byte $01, $FF, $80, $0F, $0F, $00, $07, $90
|
|
'Att 'Dec 'Sus 'Rel
|
|
byte $FF, $10, $00, $FF
|
|
|
|
'Wav 'Len 'Fre 'Vol 'LFO 'LFW 'FMa 'AMa
|
|
SoundFX2 byte $05, $FF, $00, $0F, $04, $FF, $01, $05
|
|
'Att 'Dec 'Sus 'Rel
|
|
byte $F1, $24, $00, $FF
|
|
'16step Sequencer Table
|
|
byte $F1, $78, $3C, $00, $00, $00, $F1, $78, $3C, $00, $00, $00, $00, $00, $00, $00
|
|
|
|
'Wav 'Len 'Fre 'Vol 'LFO 'LFW 'FMa 'AMa 'Heartbeat
|
|
SoundFX3 byte $00, $FF, $06, $0F, $09, $FF, $04, $05
|
|
'Att 'Dec 'Sus 'Rel
|
|
byte $F1, $F4, $F0, $0F
|
|
byte $F1, $78, $3C, $00, $00, $00, $F1, $78, $3C, $00, $00, $00, $00, $00, $00, $00
|
|
|
|
'Wav 'Len 'Fre 'Vol 'LFO 'LFW 'FMa 'AMa 'Heartbeat low
|
|
SoundFX4 byte $00, $FE, $06, $0f, $15, $FF, $04, $05
|
|
'Att 'Dec 'Sus 'Rel
|
|
byte $F1, $F4, $F0, $0F
|
|
byte $F1, $78, $3C, $00, $00, $00, $F1, $78, $3C, $00, $00, $00, $00, $00, $00, $00
|
|
|
|
'Wav 'Len 'Fre 'Vol 'LFO 'LFW 'FMa 'AMa 'Telefon
|
|
SoundFX5 byte $05, $15, $4F, $0F, $01, $04, $05, $00
|
|
'Att 'Dec 'Sus 'Rel
|
|
byte $FF, $00, $00, $FF
|
|
|
|
'Wav 'Len 'Fre 'Vol 'LFO 'LFW 'FMa 'AMa
|
|
SoundFX6 byte $06, $FF, $5F, $0F, $01, $03, $01, $00 'Teleport
|
|
'Att 'Dec 'Sus 'Rel
|
|
byte $FF, $14, $00, $FF
|
|
|
|
|
|
{{
|
|
|
|
┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
│ 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. │
|
|
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
}}
|
|
|