HIVE/TriOS-alt
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
4ca7854d78
TriOS-alt/system/regnatix/eram.spin
drohne235@googlemail.com 2803b8f31f flash\administra\admflash.spin 
- Überarbeitung der Routine zum mounten der SD-Card. Da verschiedene Karten unterschiedliches Timing haben, wird jetzt solange versucht zu mounten, bis ein Erfolg eintritt, was zusätzlich akustisch durch einen leise anschwellenden Ton angezeigt wird. Das Verfahren ist jetzt wesentlich robuster.
- rtc.setSQWOUTState(1) --> rtc.setSQWOUTState(0) deaktiviert den Frequenzausgang, verringert damit lt. DS1307-Datenblatt den Pufferstrom von 480 auf 300 nA und erhöht somit die Pufferdauer der Batterie auf das 1,6-fache.
- Plexbus-Funktionen entfernt
- Screeninterface-Funktionen zugefügt


flash\bellatrix\belflash.spin

- Anpassung für verschiedene Zeilenumbrüche in print_char eingefügt.


flash\regnatix\regflash.spin

- Der Loader hat fälschlicherweise das Warmstartflag für die Ramdisk gesetzt, wodurch sie nicht resetfest war.


forth\fib.mod

- Fibonacci-Benchmark (iterativ) in Forth.

lib\adm-fat.spin

- Fehler in setCharacterPosition: Bei einem Wechsel von einer Position > 0 auf Position = 0 wurde der erste Sektor mit falschen Daten überschrieben.


lib\reg-ios.spin

- Funktionsset für Grafikmodus 0 eingefügt
- sfx_keyoff, sfx_stop eingefügt
- printq zugefügt: Ausgabe einer Zeichenkette ohne Steuerzeichen
- Korrektur char_ter_bs
- Plexbus-Funktionen entfernt
- Screeninterface-Funktionen eingefügt
- Bellatrix-Funktionen blktrans, bmgr_load eingefügt
- Funktion os_error zugefügt für zentrale Ausgabe von Fehlern
- Korrektur BS in input-Funktion
- Funktion printblk für schnellen Blocktransfer
- Div. Fehler in den Ramdisk-Funktionen, welche jetzt auch resetfest ist.
- Funktion rd_getback um Zeichen rückwärts aus der Ramdisk zu lesen.
- Funktion ram_getfree liefert freien Speicher im eRAM


system\regnatix\eram.spin

- Korrektur BS-Steuercode

system\regnatix\hplay.spin

- Der HSS-Player hat seine Daten fals im SYS-Modus im eRAM abgelegt und so die Ramdisk beschädigt. Korrektur der Speichernutzung.

system\regnatix\regime.spin

- Korrekte Initialisierung der Ramdisk (resetfest)
- Korrektur der Bisldschirminitialisierung nach dem Laden von Bellatrix-Code
- Verwendung von ios.os_error für die Fehlerausgabe
- Fehler im Kommando "reboot" beim Kaltstart behoben
- Korrektur Ausgabe von "cogs"


system\regnatix\time.spin

- Korrektur Tipfehler


system\regnatix\basic.spin

Ich habe Femto Basic entfernt, da es nicht integraler Bestandteil von TriOS ist und mir die Zeit fehlt es an den aktuelen Stand anzupassen.
2012-02-08 17:09:41 +00:00

690 lines
48 KiB
Plaintext
Raw Blame History

{{
┌──────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ 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 : eram-tool
Chip : Regnatix
Typ : Programm
Version :
Subversion :
Logbuch :
Kommandoliste:
Notizen:
}}
OBJ
num: "glob-numbers"
ios: "reg-ios"
CON
_CLKMODE = XTAL1 + PLL16X
_XINFREQ = 5_000_000
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
VAR
'systemvariablen
byte tib[OS_TIBLEN] 'tastatur-input-buffer
byte cmdstr[OS_TIBLEN] 'kommandostring f?r interpreter
byte token1[OS_TIBLEN] 'parameterstring 1 für interpreter
byte token2[OS_TIBLEN] 'parameterstring 2 für interpreter
byte tibpos 'aktuelle position im tib
long ppos 'puffer für adresse
long pcnt 'puffer für zeilenzahl
PUB main | wflag
ios.start 'ios initialisieren
' ios.startram
ios.printnl
repeat
os_cmdinput 'kommandoeingabe
os_cmdint 'kommandozeileninterpreter
PUB os_cmdinput | charc 'sys: stringeingabe eine zeile
''funktionsgruppe : sys
''funktion : stringeingabe eine zeile
''eingabe : -
''ausgabe : -
''variablen : tib - eingabepuffer zur string
'' : tibpos - aktuelle position im tib
ios.print(@prompt2)
tibpos := 0 'tibposition auf anfang setzen
repeat until (charc := ios.keywait) == $0D 'tasten einlesen bis return
if (tibpos + 1) < OS_TIBLEN 'zeile noch nicht zu lang?
case charc
ios#CHAR_BS: 'backspace
if tibpos > 0 'noch nicht anfang der zeile erreeicht?
tib[tibpos--] := 0 'ein zeichen aus puffer entfernen
ios.printbs 'steuerzeichen an terminal senden
other: 'zeicheneingabe
tib[tibpos++] := charc 'zeichen speichern
ios.printchar(charc) 'zeichen ausgeben
ios.printnl
tib[tibpos] := 0 'string abschließen
tibpos := charc := 0 'werte rücksetzen
PUB os_nxtoken1: stradr 'sys: token 1 von tib einlesen
''funktionsgruppe : sys
''funktion : nächsten token im eingabestring suchen und stringzeiger übergeben
''eingabe : -
''ausgabe : stradr - adresse auf einen string mit dem gefundenen token
''variablen : tib - eingabepuffer zur string
'' : tibpos - aktuelle position im tib
'' : token - tokenstring
stradr := os_tokenize(@token1)
PUB os_nxtoken2: stradr 'sys: token 2 von tib einlesen
''funktionsgruppe : sys
''funktion : nächsten token im eingabestring suchen und stringzeiger übergeben
''eingabe : -
''ausgabe : stradr - adresse auf einen string mit dem gefundenen token
''variablen : tib - eingabepuffer zur string
'' : tibpos - aktuelle position im tib
'' : token - tokenstring
stradr := os_tokenize(@token2)
PUB os_tokenize(token):stradr | i 'sys: liest nächsten token aus tib
i := 0
if tib[tibpos] <> 0 'abbruch bei leerem string
repeat until tib[tibpos] > ios#CHAR_SPACE 'führende leerzeichen ausbenden
tibpos++
repeat until (tib[tibpos] == ios#CHAR_SPACE) or (tib[tibpos] == 0) 'wiederholen bis leerzeichen oder stringende
byte[token][i] := tib[tibpos]
tibpos++
i++
else
token := 0
byte[token][i] := 0
stradr := token
PUB os_nextpos: tibpos2 'sys: setzt zeiger auf nächste position
''funktionsgruppe : sys
''funktion : tibpos auf nächstes token setzen
''eingabe : -
''ausgabe : tibpos2 - position des nächsten tokens in tib
''variablen : tib - eingabepuffer zur string
'' : tibpos - aktuelle position im tib
if tib[tibpos] <> 0
repeat until tib[tibpos] > ios#CHAR_SPACE 'führende leerzeichen ausbenden
tibpos++
return tibpos
PUB os_cmdint 'sys: kommandointerpreter
''funktionsgruppe : sys
''funktion : kommandointerpreter; zeichenkette ab tibpos wird als kommando interpretiert
'' : tibpos wird auf position hinter token gesetzt
''eingabe : -
''ausgabe : -
''variablen : tib - eingabepuffer zur string
'' : tibpos - aktuelle position im tib
repeat 'kommandostring kopieren
cmdstr[tibpos] := tib[tibpos]
tibpos++
until (tib[tibpos] == ios#CHAR_SPACE) or (tib[tibpos] == 0) 'wiederholen bis leerzeichen oder stringende
cmdstr[tibpos] := 0 'kommandostring abschließen
os_cmdexec(@cmdstr) 'interpreter aufrufen
tibpos := 0 'tastaturpuffer zurücksetzen
tib[0] := 0
PUB os_cmdexec(stradr) 'sys: kommando im ?bergebenen string wird als kommando interpretiert
{{os_smdexec - das kommando im ?bergebenen string wird als kommando interpretiert
stradr: adresse einer stringvariable die ein kommando enth?lt}}
if strcomp(stradr,string("help")) 'help
ios.print(@help1)
elseif strcomp(stradr,string("d")) 'd display - speicheranzeige
ram_disp
elseif strcomp(stradr,string("dl")) 'd display long - speicheranzeige
ram_displong
elseif strcomp(stradr,string("n")) 'n next - anzeige fortsetzen
ram_next
elseif strcomp(stradr,string("m")) 'm modify - speicher modifizieren
ram_mod
elseif strcomp(stradr,string("l")) 'l modify - long
ram_lmod
elseif strcomp(stradr,string("info"))
ram_info
elseif strcomp(stradr,string("f"))
ram_fill
elseif strcomp(stradr,string("fu")) 'fill im userbereich
ram_fillusr
elseif strcomp(stradr,string("rbas"))
ram_setrbas
elseif strcomp(stradr,string("sysvar"))
ram_sysvar
elseif strcomp(stradr,string("load")) 'load -
ram_load
elseif strcomp(stradr,string("cls")) 'cls -
ios.printcls
elseif strcomp(stradr,string("bye")) 'bye
ios.stop
elseif strcomp(stradr,string("xinit")) 'rdisk initialisieren
rd_init
elseif strcomp(stradr,string("xnew")) 'neue ram-datei erstellen
rd_new
elseif strcomp(stradr,string("xhead")) 'header der dateien anzeigen
rd_header
elseif strcomp(stradr,string("xdel")) 'ram-datei löschen
rd_del
elseif strcomp(stradr,string("xren")) 'ram- datei umbenennen
rd_rename
elseif strcomp(stradr,string("xdir")) 'ram-dateien liste anzeigen
rd_dir
elseif strcomp(stradr,string("xftab")) 'tabelle geöffnete dateien anzeigen
rd_ftab
elseif strcomp(stradr,string("xopen")) 'ram-datei öffnen
rd_open
elseif strcomp(stradr,string("xsave")) 'ram-datei auf sd speichern
rd_save
elseif strcomp(stradr,string("xclose")) 'ram-datei schliessen
rd_close
elseif strcomp(stradr,string("xseek")) 'dateizeiger setzen
rd_seek
elseif strcomp(stradr,string("xput")) 'wert in geöffnete datei schreiben
rd_put
elseif strcomp(stradr,string("xget")) 'wert aus geöffneter datei lesen
rd_get
elseif strcomp(stradr,string("xwrite")) 'wert an def. adresse in datei schreiben
rd_write
elseif strcomp(stradr,string("xread")) 'wert von def. adresse aus datei lesen
rd_read
elseif strcomp(stradr,string("xload")) 'ram-datei von sd laden
rd_load
elseif strcomp(stradr,string("xtype")) 'ram-datei (text) ausgeben
rd_type
elseif strcomp(stradr,string("debug"))
debug
else 'kommando nicht gefunden
ios.print(stradr)
ios.print(@prompt3)
ios.printnl
PRI debug
ios.rd_init
ios.rd_newfile(string("d1"),8)
ios.rd_newfile(string("d2"),8)
ios.rd_newfile(string("d3"),8)
ios.rd_newfile(string("d4"),8)
ios.rd_newfile(string("d5"),8)
rd_dir
PRI rd_type | stradr,len,fnr 'rd: text ausgeben
stradr := os_nxtoken1 'dateinamen von kommandozeile holen
fnr := ios.rd_open(stradr) 'datei öffnen
ifnot fnr == -1
len := ios.rd_len(fnr)
ios.rd_seek(fnr,0)
repeat len
ios.printchar(ios.rd_get(fnr))
ios.rd_close(fnr)
PRI rd_load | stradr,len,fnr 'rd: datei in ramdisk laden
stradr := os_nxtoken1 'dateinamen von kommandozeile holen
ifnot os_error(ios.sdopen("r",stradr)) 'datei öffnen
len := ios.sdfattrib(ios#F_SIZE)
ios.rd_newfile(stradr,len) 'datei erzeugen
fnr := ios.rd_open(stradr)
ios.rd_seek(fnr,0)
repeat len 'datei einlesen
ios.rd_put(fnr,ios.sdgetc)
ios.sdclose
ios.rd_close(fnr)
PRI rd_save | stradr, fnr, len 'rd: datei aus ramdisk speichern
stradr := os_nxtoken1
fnr := ios.rd_open(stradr)
ifnot fnr == -1
len := ios.rd_len(fnr)
ifnot os_error(ios.sdnewfile(stradr))
ifnot os_error(ios.sdopen("W",stradr))
ios.print(string("Schreibe Datei..."))
repeat len
ios.sdputc(ios.rd_get(fnr))
ios.sdclose
ios.print(string(" ok"))
ios.printnl
ios.rd_close(fnr)
PRI rd_rename
os_error(ios.rd_rename(os_nxtoken1,os_nxtoken2))
PRI rd_seek | fnr,wert 'rd: dateizeiger setzen
fnr := num.FromStr(os_nxtoken1,num#HEX)
wert := num.FromStr(os_nxtoken1,num#HEX)
ios.rd_seek(fnr,wert)
PRI rd_put | fnr,wert,chars 'rd: werte ausgeben
fnr := num.FromStr(os_nxtoken1,num#HEX)
wert := num.FromStr(os_nxtoken1,num#HEX)
chars := num.FromStr(os_nxtoken1,num#HEX)
repeat chars
ios.rd_put(fnr,wert)
PRI rd_get | fnr,chars,i,j 'rd: werte einlesen
fnr := num.FromStr(os_nxtoken1,num#HEX)
chars := num.FromStr(os_nxtoken1,num#HEX)
i := j := 0
repeat chars
ifnot i
ios.printnl
ios.printhex(j,4)
ios.printchar(":")
ios.printhex(ios.rd_get(fnr),2)
ios.printchar(" ")
if i++ == 7
i := 0
j++
ios.printnl
PRI rd_write | fnr,adr,wert 'rd: wert schreiben
fnr := num.FromStr(os_nxtoken1,num#HEX)
adr := num.FromStr(os_nxtoken1,num#HEX)
wert := num.FromStr(os_nxtoken1,num#HEX)
ios.rd_wrbyte(fnr,wert,adr)
PRI rd_read | fnr,adr 'rd: wert lesen
fnr := num.FromStr(os_nxtoken1,num#HEX)
adr := num.FromStr(os_nxtoken1,num#HEX)
ios.printhex(ios.rd_rdbyte(fnr,adr),2)
ios.printnl
PRI rd_close 'rd: datei schliessen
ios.rd_close(num.FromStr(os_nxtoken1,num#HEX))
PRI rd_open 'rd: datei öffnen
ifnot ios.rd_open(os_nxtoken1)
os_error(5)
PRI rd_ftab | i 'rd: anzeige ftab
i := 0
repeat ios#FILES
ios.printnl
ios.printhex(i,2)
ios.printchar(":")
ios.printhex(ios.rd_getftab(i*3+0),6)
ios.printchar(" ")
ios.printhex(ios.rd_getftab(i*3+1),6)
ios.printchar(" ")
ios.printhex(ios.rd_getftab(i*3+2),6)
ifnot i
ios.print(string(" user"))
i++
ios.printnl
PRI rd_del | adr 'rd: datei löschen
os_error(ios.rd_del(os_nxtoken1))
PRI rd_dir | stradr,len 'rd: dir anzeigen
if ios.ram_rdbyte(ios#sysmod,ios#RAMDRV)
ios.rd_dir
repeat
len := ios.rd_dlen
stradr := ios.rd_next
if stradr
ios.print(stradr)
ios.printtab
ios.printdec(len)
ios.printnl
until stradr == 0
else
os_error(1)
PRI rd_header|hp,nx,len,i 'rd: header
hp := ios#STARTRD
repeat
nx := ios.ram_rdlong(ios#sysmod,hp)
len := ios.ram_rdlong(ios#sysmod,hp+4)
ios.print(string("[adr-header] = $"))
ios.printhex(hp,8)
ios.printnl
ios.print(string("[adr-next ] = $"))
ios.printhex(nx,8)
ios.printnl
ios.print(string("[len ] = $"))
ios.printhex(len,8)
ios.printchar(" ")
ios.printdec(len)
ios.printnl
ios.print(string("[name ] = "))
i := 0
repeat 12
ios.printchar(ios.ram_rdbyte(ios#sysmod,hp+8+i++))
hp := nx
ios.print(string(" <*/q> : "))
if ios.keywait == "q"
quit
ios.printnl
until nx == 0
ios.printnl
PRI rd_new 'rd: new file
ios.rd_newfile(os_nxtoken1,num.FromStr(os_nxtoken2,num#DEC))
PRI rd_init 'rd: rdisk initialisieren
ios.rd_init
PRI ram_sysvar | i 'ram: systemvariablen anzeigen
ios.print(string("LOADERPTR = "))
ios.printchar("[")
ios.printhex(ios#LOADERPTR,6)
ios.print(string("] : "))
ios.printhex(ios.ram_rdlong(0,ios#LOADERPTR),6)
ios.printnl
ios.print(string("MAGIC = "))
ios.printchar("[")
ios.printhex(ios#MAGIC,6)
ios.print(string("] : "))
ios.printhex(ios.ram_rdbyte(0,ios#MAGIC),6)
ios.printnl
ios.print(string("SIFLAG = "))
ios.printchar("[")
ios.printhex(ios#SIFLAG,6)
ios.print(string("] : "))
ios.printhex(ios.ram_rdbyte(0,ios#SIFLAG),6)
ios.printnl
ios.print(string("BELDRIVE = "))
i := ios#BELDRIVE
repeat 12
ios.printchar(ios.ram_rdbyte(0,i++))
ios.printnl
ios.print(string("PARAM = "))
i := ios#PARAM
repeat 32
ios.printchar(ios.ram_rdbyte(0,i++))
ios.printnl
ios.print(string("RAMEND = "))
ios.printchar("[")
ios.printhex(ios#RAMEND,6)
ios.print(string("] : "))
ios.printhex(ios.ram_getend,6)
ios.printnl
ios.print(string("RAMBAS = "))
ios.printchar("[")
ios.printhex(ios#RAMBAS,6)
ios.print(string("] : "))
ios.printhex(ios.ram_getbas,6)
ios.printnl
PRI ram_setrbas 'ram: basisadresse setzen
ios.ram_setbas(num.FromStr(os_nxtoken1,num#HEX))
PRI ram_fill | adr,len,wert 'ram: speicherbereich füllen
adr := ram_symbols
len := num.FromStr(os_nxtoken1,num#HEX)
wert := num.FromStr(os_nxtoken1,num#HEX)
repeat len
ios.ram_wrbyte(ios#sysmod,wert,adr++)
PRI ram_fillusr | adr,len,wert 'ram: speicherbereich füllen
adr := ram_symbols
len := num.FromStr(os_nxtoken1,num#HEX)
wert := num.FromStr(os_nxtoken1,num#HEX)
repeat len
ios.ram_wrbyte(ios#usrmod,wert,adr++)
PRI ram_info 'ram: infos anzeigen
ios.print(string("RBAS : $"))
ios.printhex(ios.ram_getbas,6)
ios.print(string(" REND : $"))
ios.printhex(ios.ram_getend,6)
ios.print(string(" RLEN : $"))
ios.printhex(ios.ram_getend - ios.ram_getbas,6)
ios.print(string(" RDRV : $"))
ios.printhex(ios.ram_rdbyte(ios#sysmod,ios#RAMDRV),2)
ios.printnl
PRI ram_mod | wert,adresse,stradr 'ram: rambereich beschreiben
{{rmodify <adr b1 b2 b3 ...> - rambereich beschreiben, adresse und werte
folgen auf kommandozeile}}
adresse := ram_symbols 'adresse von kommandozeile holen
repeat
if (stradr := os_nxtoken1)
wert := num.FromStr(stradr,num#HEX) 'nächstes byte von kommandozeile holen
ios.ram_wrbyte(0,wert,adresse++) 'wert in eram schreiben
until stradr == 0 'keine parameter mehr?
PRI ram_lmod | wert,adresse,stradr 'ram: rambereich beschreiben (long)
{{rmodify <adr l1 l2 l3 ...> - rambereich beschreiben, adresse und werte
folgen auf kommandozeile}}
adresse := ram_symbols 'adresse von kommandozeile holen
repeat
if (stradr := os_nxtoken1)
wert := num.FromStr(stradr,num#HEX) 'nächstes byte von kommandozeile holen
ios.ram_wrlong(0,wert,adresse) 'long in eram schreiben
adresse := adresse + 4
until stradr == 0 'keine parameter mehr?
PRI ram_disp | adresse,zeilen,sadr 'ram: rambereich anzeigen
{{rdisplay <adr anz> - rambereich anzeigen, adresse und zeilenzahl folgt auf kommandozeile}}
adresse := ram_symbols
zeilen := num.FromStr(os_nxtoken1,num#HEX) 'zeilenzahl von kommandozeile holen
if zeilen == 0
zeilen := RMON_ZEILEN
ram_print(adresse,zeilen)
PRI ram_symbols:adresse | sadr 'ram: adresse auflösen
sadr := os_nxtoken1
if strcomp(sadr,string("bas"))
adresse := ios.ram_getbas
elseif strcomp(sadr,string("end"))
adresse := ios.ram_getend
elseif strcomp(sadr,string("sys"))
adresse := ios.ram_getend + 1
elseif strcomp(sadr,string("rd:"))
adresse := ios.rd_searchdat(os_nxtoken1)
else
adresse := num.FromStr(sadr,num#HEX) 'adresse von kommandozeile holen
PRI ram_displong | sadr,adresse,wert 'ram: rambereich als long anzeigen
adresse := ram_symbols
repeat
ios.printnl
if (adresse => ios.ram_getbas) & (adresse =< ios.ram_getend)
ios.setcolor(2)
ios.printhex(adresse - ios.ram_getbas,6)
ios.setcolor(0)
else
ios.print(string("------"))
ios.printchar("-")
ios.printhex(adresse,6) 'adresse ausgeben
ios.printchar(" ")
wert := ios.ram_rdlong(0,adresse)
ios.printhex(wert,6)
ios.printchar(":")
ios.printbin(wert,32)
ios.print(string(" <*/q> : "))
adresse += 4
until ios.keywait == "q"
ios.printnl
PRI ram_next 'ram: anzeige fortsetzen
ram_print(ppos,pcnt)
PRI ram_print(adresse,zeilen)|wert,pbas,pend 'ram: ausgabe
pbas := ios.ram_getbas 'rbas vom system sichern
pend := ios.ram_getend
repeat zeilen 'zeilen
if (adresse => pbas) & (adresse =< pend)
ios.setcolor(2)
ios.printhex(adresse-pbas,6)
ios.setcolor(0)
else
ios.print(string("------"))
ios.printchar("-")
ios.printhex(adresse,6) 'adresse ausgeben
ios.printchar(ios#CHAR_SPACE)
repeat RMON_BYTES 'hexwerte ausgeben
wert := ios.ram_rdbyte(0,adresse++)
ios.printhex(wert,2) 'byte ausgeben
ios.printchar(":")
adresse := adresse - rmon_bytes
ios.printchar(ios#CHAR_SPACE)
repeat RMON_BYTES 'zeichen ausgeben
wert := ios.ram_rdbyte(0,adresse++)
if wert < $20
wert := 46
ios.printchar(wert) 'byte ausgeben
ios.printchar($0D)
ppos := adresse
pcnt := zeilen
PRI ram_load | adr,len,stradr,status,char,i 'ram: lade datei nach eramadr
{{sdload - adr len dateiname lade datei nach eram-adr}}
adr := num.FromStr(os_nxtoken1,num#HEX) 'adresse von kommandozeile holen
len := num.FromStr(os_nxtoken1,num#HEX) 'l?nge von kommandozeile holen
stradr := os_nxtoken1 'dateinamen von kommandozeile holen
status := ios.sdopen("r",stradr) 'datei ?ffnen
if status > 0
ios.print(string("Status : "))
ios.printdec(status)
ios.printnl
if status == 0
repeat i from 0 to len
char := ios.sdgetc
ios.ram_wrbyte(0,char,adr + i)
ios.sdclose
PUB os_error(err):error 'sys: fehlerausgabe
if err
ios.printnl
ios.print(@err_s1)
ios.printdec(err)
ios.print(string(" : $"))
ios.printhex(err,2)
ios.printnl
ios.print(@err_s2)
case err
0: ios.print(@err0)
1: ios.print(@err1)
2: ios.print(@err2)
3: ios.print(@err3)
4: ios.print(@err4)
5: ios.print(@err5)
6: ios.print(@err6)
7: ios.print(@err7)
8: ios.print(@err8)
9: ios.print(@err9)
10: ios.print(@err10)
11: ios.print(@err11)
12: ios.print(@err12)
13: ios.print(@err13)
14: ios.print(@err14)
15: ios.print(@err15)
16: ios.print(@err16)
17: ios.print(@err17)
18: ios.print(@err18)
19: ios.print(@err19)
20: ios.print(@err20)
OTHER: ios.print(@errx)
ios.printnl
error := err
DAT
prompt1 byte "ok ", $0d, 0
prompt2 byte ": ", 0
prompt3 byte "? ",0
wait1 byte "<WEITER? */q:>",0
help1 file "eram.txt"
byte $0d,0
err_s1 byte "Fehlernummer : ",0
err_s2 byte "Fehler : ",0
err0 byte "no error",0
err1 byte "fsys unmounted",0
err2 byte "fsys corrupted",0
err3 byte "fsys unsupported",0
err4 byte "not found",0
err5 byte "file not found",0
err6 byte "dir not found",0
err7 byte "file read only",0
err8 byte "end of file",0
err9 byte "end of directory",0
err10 byte "end of root",0
err11 byte "dir is full",0
err12 byte "dir is not empty",0
err13 byte "checksum error",0
err14 byte "reboot error",0
err15 byte "bpb corrupt",0
err16 byte "fsi corrupt",0
err17 byte "dir already exist",0
err18 byte "file already exist",0
err19 byte "out of disk free space",0
err20 byte "disk io error",0
err21 byte "command not found",0
errx byte "undefined",0
Reference in New Issue View Git Blame Copy Permalink